Umgekehrte Pyramide

[Anfaengerin]

Hallo zusammen,

ich habe die Tage an einer umgekehrten Pyramide aus Sternchen gearbeitet. Da ich selbst nicht auf die Idee gekommen bin, wie ich z.B. die Sternchen am Anfang viele sein lassen konnte, hab ich im Internet nach einer Lösung gesucht.

Die leuchtet mir auch soweit ein, nur der letzte Teil nicht (für die Sternchen).

for (int k = 1; k <= (2 * n - (2 * i-1)); k++)

n ist die Anzahl der Zeilen.

Der ganze Code sieht so aus:

  for (int i = 1; i <= n; i++) {

                for (int j = 1; j < i; j++) {
                    System.out.print(" ");
                }


                for (int k = 1; k <= (2 * n - (2 * i-1)); k++) {
                    System.out.print("*");


System.out.println();

Könnte mir jemand dieses Stück erklären:

for (int k = 1; k <= (2 * n - (2 * i-1)); k++)

 

[KonradN]

Bei sowas würde ich Dir raten, immer genau aufzumalen, was denn angezeigt werden soll (bzw. hier: wird). Dann kannst Du Elemente zählen und so.

So hast du die äußere Zeile, die einfach nur die Anzahl der Zeilen (n) durchzählt und i ist dann die Zeilennummer, beginnend bei 1 für die erste Zeile bis hin zu n für die letzte Spalte.

Dann musst Du ja die Einrückung machen. Diese ist in ersten Zeile 0 Leerzeichen, in der zweiten Zeile 1 Leerzeichen bis hin zu (n-1) Leerzeichen in der n-ten Zeile. Das macht dann die Schleife mit dem j.

Dann bleibt als letztes die Frage, wie viele Sternchen gemalt werden müssen. Und da musst Du dann halt schauen, wie viele das sind. Bei n=1 hast Du nur ein einzelnes Sternchen. Bei n=2 hast Du ja erst 3 Sternchen und dann 1 Sternchen. bei n=3 hast Du erst 5, dann 3 und dann 1 Sternchen.

Jetzt kannst Du einmal schauen, wie viele Sternchen Du maximal hast. Auf was für eine Formel kommst Du da? Siehst Du es?



2*n - 1

2*1 - 1 = 1
2*2 -1 = 3
2*3 - 1 = 5

Jetzt ist die Frage: Wie viele Sternchen werden von Zeile zu Zeile weniger? Es sind immer 2 Zeichen weniger.
In Zeile 1 ziehen wir keines ab. In Zeile 2 ziehen wir 2 ab. In Zeile 3 ziehen wir 4 ab...
Also als Formel könnte man sagen: 2*(i-1) = 2*i -2 was wir abziehen müssen.

Das kann man nun mit der Formel oben Ausdrücken:
Die maximale Anzahl Sternchen (die in der ersten Zeile) sind: 2*n -1
Abzuziehen sind 2*i - 2
Also ist die Anzahl der Sternchen in der Zeile i:
2*n -1 - (2*i -2)
= 2*n -1 - 2*i + 2
= 2*n - 2 *i + 1
Jetzt kann man das +1 noch in eine Klammer ziehen mit dem - davor:
= 2*n - (2*i - 1)


Das ist dann die Formel und das ist halt die Anzahl der Sternchen auf der Zeile. Und du hast eine Zählschleife von 1 bis einschließlich diesem Wert.

 

[Anfaengerin]

Vielen Dank, wenn ich es so lese, macht es Sinn. Das werd ich mir noch einige Male zu Gemüte führen. Vielen Dank!

Worüber ich mich auch gewundert habe, ist, warum ich in keiner Schleife abwärts zählen musste, also j--, oder so, obwohl er ja die Sternchen effektiv trotzdem runterzählt.

 

[KonradN]

Du ziehst ja das doppelte i ab. Dadurch wird die Grenze der Schleife mit k ja immer kleiner (um 2 von Zeile zu Zeile).

 

[Barista]

Könnte mir jemand dieses Stück erklären:

An diesem Code merkt man, was mit codieren gemeint ist, für die Maschine verständlich machen, aber für den Menschen unverständlich machen.

Aber Code muss nicht so schlecht sein.

Ich weiß nicht ob Du eine IDE benutzt, dies würde das Analysieren einfacher machen, muss man aber auch erst mal beherrschen.

Wenn Du nur einen Texteditor benutzt (Notepad unter Windows oder so), dann kannst Du Suchen und Ersetzen (ganzes Wort).

Dann würde ich umbenennen:

n zu hoehe

i zu aktuelleZeilenNr

k zu positionInFlaeche

Die Schleife mir dem print Leerzeichen könntest Du in eine Methode auslagern: printLinkerRand(int breite)

Dann wird das Ganze wahrscheinlich verständlicher.

 

[Anfaengerin]

Du ziehst ja das doppelte i ab. Dadurch wird die Grenze der Schleife mit k ja immer kleiner (um 2 von Zeile zu Zeile).

Ja stimmt, so ähnlich hab ich mir das auch gedacht. In jedem Fall danke!

 

[Anfaengerin]

Hallo, mich würde auch mal interessieren, wo du den Code herhast. Möchte ein wenig Forensik betreiben. Dass er für Anfänger unangemessen ist, wurde ja schon gesagt. ... BTW, in Zeile 9 oder 10 fehlt eine schließende Klammer.

Da hab ich ganz "wild" im Internet gesucht, nein, die Quelle weiß ich nicht mehr. Wenn ich eine schließende Klammer versehentlich nicht mitkopiert habe, tut es mir leid: das Programm läuft so.

Mein Problem war nicht die abstrakte Beschriftung, sondern wie man auf 2n-2i+1 gekommen war. Erinnert mich im Prozess ein wenig daran, eine Zahlenfolge fortsetzen zu müssen und die Gesetzmäßigkeit dahinter zu erahnen.

 

[Anfaengerin]

Ja, ist auch ein bisschen so, wie ein IQTest.


2n sind die gesamten Zeichen in einer Zeile,
davon werden 2i+1 abgezogen,
also genau so viele, wie in der 2i.-Zeile nicht benötigt werden

Zum Glück macht sich der IQ nicht nur daran fest, wie gut man Zahlenfolgen fortsetzen kann.

Nein, 2 n sind nicht die gesamten Zeichen in einer Zeile, die maximale Anzahl an Sternchen ist 2n-1, in der obersten Zeile.

 

[KonradN]

Doch weil es eine in ein Rechteck gezeichnete Pyramide auf dem Kopf ist.

@Anfaengerin hat es doch richtig geschrieben: Es sind 2n -1. Wenn man sich die Zahlen anschaut, dann wird das auch klar, denn man hat ja 1, 3, 5, 7, 9, 11, ... Sternchen. Daher ganz klar nicht 2n, denn das wäre ja eine gerade Zahl.

... Aber die Quelle möchtest du patu nicht angeben?

die Quelle weiß ich nicht mehr.

 

[KonradN]

@Anfaengerin Nicht irritieren lassen. Das ist "unser Tobias", jemand, der regelmäßig gebannt wird und dann immer wieder mit neuen Accounts wieder kommt. Daher nicht wundern: Dieser Account ist nun auch wieder weg ...

 

[Anfaengerin]

Achso, lol, verstehe.

 

[Barista]

Vielleicht wird es einfacher, wenn man

java.lang.String.repeat(int)

verwendet.

Die for-Schleifen haben ja eine doppelte Aufgabe, die Anzahl zu wiederholender Zeichen zu berechenen und dann noch das Wiederholen selbst.

 

[Barista]

package org.java_forum;

/**
 * https://www.java-forum.org/thema/umgekehrte-pyramide.204743/
 */
public class Pyramide
{
    public static void main(String[] args)
    {
        pyramide( 3 );

        System.out.println();

        pyramideUmgekehrt( 3 );
    }

    public static void pyramide(
            final int hoehe )
    {
        for ( int zeileNr = 0 ; zeileNr < hoehe ; zeileNr++ )
        {
            System.out.print( " ".repeat( hoehe - zeileNr ) );

            System.out.print( "*".repeat( zeileNr * 2 + 1 ) );

            System.out.println();
        }
    }

    public static void pyramideUmgekehrt(
            final int hoehe )
    {
        for ( int zeileNrUmgekehrt = hoehe - 1 ; zeileNrUmgekehrt >= 0 ; zeileNrUmgekehrt-- )
        {
            System.out.print( " ".repeat( hoehe - zeileNrUmgekehrt ) );

            System.out.print( "*".repeat( zeileNrUmgekehrt * 2 + 1 ) );

            System.out.println();
        }
    }

}

Ich glaube schon, dass die "Beschriftung" eine Rolle spielt.

In der Java-Tradition (die zurück geht auf die Tradition C / C++) habe ich die Zeilen-Nummer mit Null begonnen.

Zuerst habe ich die Methode pyramide geschrieben.

Für pyramideUmgekehrt habe ich die Methode pyramide einfach kopiert und einfach rückwärts gezählt.

Geht fast von selbst.

Ok, der linke Rand ist ein Zeichen zu breit, ist leicht zu korrigieren.