Verschachtelung von For-Schleife in While Schleife

[Beginner2510]

Also ich möchte die For-Schleifen mit While Schleifen ersetzen. Das will unser Prof. so. Hier zu einem Ausschnitt des eigentlichen Programms

for (stern = 0; stern < 10; stern++) {
            for (dreieck = 0; dreieck < 10; dreieck++) {
                for (raute = 0; raute < 10; raute++) {
                    int zahl1 = stern * 100 + dreieck * 10 + raute;

                    for (unendlich = 0; unendlich < 10; unendlich++) {
                        for (dreieckAndersherum = 0; dreieckAndersherum < 10; dreieckAndersherum++) {
                            int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;

                            for (quadrat = 0; quadrat < 10; quadrat++) {
                                int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;

                                if (zahl1 + zahl2 == zahl3){

hier mein Ansatz

    while (stern < 10) {

            while (dreieck < 10) {

                while (raute < 10) {
                    int zahl1 = stern * 100 + dreieck * 10 + raute;
                    while (unendlich < 10) {

                        while (dreieckAndersherum < 10) {

                            dreieckAndersherum++;

                            int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;

                            while (quadrat < 10) {

                                int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;
                                dreieck++;
                                quadrat++;
                                unendlich++;
                                stern++;
                                
                                if(zahl1 +zahl2 == zahl3)

 

[httpdigest]

Eine for-Schleife der Form:

for (initializer; condition; increment) {
  statement;
}

ist äquivalent zu folgender while-Schleife:

initializer;
while (condition) {
  statement;
  increment;
}

Somit ist deine Lösung noch unvollständig.

EDIT: Außerdem ist mir gerade aufgefallen, dass du in deiner Lösung die Inkrements aller äußeren Schleifen in der allerinnersten Schleife tust. Das ist falsch. Die jeweiligen Inkrements passieren nachdem der jeweilige Rumpf einer Schleife ausgeführt wurde.

Mein Tipp: Betrachte einfach jede Schleife für sich alleine (ohne die inneren Schleifen) und transformiere jede Schleife für sich, bis du bei der innersten Schleife angekommen bist. Wenn du dir also erstmal nur die äußere Schleife anguckst, dann ist gemäß der von mir genannten Form der initializer: `stern = 0`, die condition: `stern < 10` und das increment: `stern++`. Der Rumpf bzw. das Statement der Schleife ist dann einfach die gesamte `for (dreieck = 0; dreieck < 10; dreieck++) { ... }` Schleife. Wenn du also nur erstmal die äußere Schleife transformierst, erhältst du:

stern = 0;
while (stern < 10) {
  for (dreieck = 0; dreieck < 10; dreieck++) { ... }
  stern++;
}

 

[Beginner2510]

Nur kommen hier andere Ergebnisse raus, als bei der For-Schleife. Oder habe ich noch einen Fehler?

        int stern = 0;
        int dreieck = 0;
        int raute = 0;
        int unendlich = 0;
        int dreieckAndersherum = 0;
        int quadrat = 0;
        int kreis = 0;
        int kleeblatt = 0;
        int kreisMitPunkt = 0;
        int kreisMitKreuz = 0;

        while (stern < 10) {
            stern++;
            while (dreieck < 10) {
                dreieck++;
                while (raute < 10) {
                    int zahl1 = stern * 100 + dreieck * 10 + raute;

                    while (unendlich < 10) {
                        unendlich++;
                        while (dreieckAndersherum < 10) {
                            dreieckAndersherum++;
                            int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;

                            while (quadrat < 10) {
                                quadrat++;
                                int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;

                                if (zahl1 + zahl2 == zahl3)
                                    ;
                                {

                                    System.out.println(zahl3);

                                }

                            }
                        }

                    }
                }
            }
        }
    }
}

 

[httpdigest]

Ich sagte: Das Inkrement passiert nachdem der jeweilige Schleifenrumpf ausgeführt wurde. Identifiziere doch einfach die vier Bestandteile jeder Schleife und wende die Umwandlungsform an, die ich dir genannt hatte. Es ist wirklich nur einfaches Suchen und Ersetzen. Und die Initialisierung der Variablen ist auch noch falsch.

 

[Beginner2510]

Das mit den Inkrementen stimmt immer noch nicht ganz, oder? :/

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int stern = 0;
        int dreieck = 0;
        int raute = 0;
        int unendlich = 0;
        int dreieckAndersherum = 0;
        int quadrat = 0;
        int kreis = 0;
        int kleeblatt = 0;
        int kreisMitPunkt = 0;
        int kreisMitKreuz = 0;

        stern = 0;
        while (stern < 10) {
            dreieck = 0;
            while (dreieck < 10) {
                raute = 0;
                while (raute < 10) {
                    int zahl1 = stern * 100 + dreieck * 10 + raute;

                    unendlich = 0;
                    while (unendlich < 10) {
                        dreieckAndersherum = 0;
                        while (dreieckAndersherum < 10) {
                            int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;

                            quadrat = 0;
                            while (quadrat < 10) {
                                int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;

                                raute++;
                                stern++;
                                dreieck++;
                                unendlich++;
                                dreieckAndersherum++;
                                quadrat++;

                                if (zahl1 + zahl2 == zahl3)
                                    ;
                                {
                                    System.out.println(zahl3);

                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

 

[httpdigest]

Ich habe langsam das Gefühl, du probierst einfach wild herum, statt strukturiert vorzugehen. Hier nochmal meine Antwort von eben:

Eine for-Schleife der Form:

for (initializer; condition; increment) {
  statement;
}

ist äquivalent zu folgender while-Schleife:

initializer;
while (condition) {
  statement;
  increment;
}

...
Mein Tipp: Betrachte einfach jede Schleife für sich alleine (ohne die inneren Schleifen) und transformiere jede Schleife für sich, bis du bei der innersten Schleife angekommen bist. Wenn du dir also erstmal nur die äußere Schleife anguckst, dann ist gemäß der von mir genannten Form der initializer: `stern = 0`, die condition: `stern < 10` und das increment: `stern++`. Der Rumpf bzw. das Statement der Schleife ist dann einfach die gesamte `for (dreieck = 0; dreieck < 10; dreieck++) { ... }` Schleife. Wenn du also nur erstmal die äußere Schleife transformierst, erhältst du:

stern = 0;
while (stern < 10) {
  for (dreieck = 0; dreieck < 10; dreieck++) { ... }
  stern++;
}

 

[Beginner2510]

Ja und das Increment muss nach dem Statement, also hinter den ganzen Schleifen?

 

[Creepaz]

Increment kommt generell immer IN die Schleife, wie @httpdigest dir oben schon mal gezeigt hat.

while (condition) { 
    statement;  
    increment;  //<-- IN die jeweilige Schleife
}

Nach dem Statement ist an sich schon richtig, aber was verstehst unter "hinter" den ganzen Schleifen? Wenn du damit nur meinst nach dem Statement, aber vor Ende der Schleife, bist du richtig.

 

[Beginner2510]

Ich glaube, ich habs 🙂

public static void main(String[] args) {
        // TODO Auto-generated method stub

        int stern = 0;
        int dreieck = 0;
        int raute = 0;
        int unendlich = 0;
        int dreieckAndersherum = 0;
        int quadrat = 0;
        int kreis = 0;
        int kleeblatt = 0;
        int kreisMitPunkt = 0;
        int kreisMitKreuz = 0;

        stern = 0;
        while (stern < 10) {
            dreieck = 0;
            while (dreieck < 10) {

                raute = 0;
                while (raute < 10) {

                    int zahl1 = stern * 100 + dreieck * 10 + raute;

                    unendlich = 0;
                    while (unendlich < 10) {

                        dreieckAndersherum = 0;
                        while (dreieckAndersherum < 10) {

                            int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;
                            quadrat = 0;
                            while (quadrat < 10) {
                                int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;

                                if (zahl1 + zahl2 == zahl3)
                                    ;

                                {
                                    System.out.println(zahl3);

                                }

                                quadrat++;
                            }
                            dreieckAndersherum++;
                        }
                        unendlich++;
                    }
                    raute++;
                }
                dreieck++;
            }
            stern++;
        }

    }
}

 

[Creepaz]

Ich glaube, ich habs 🙂

public static void main(String[] args) {
        // TODO Auto-generated method stub

        int stern = 0;
        int dreieck = 0;
        int raute = 0;
        int unendlich = 0;
        int dreieckAndersherum = 0;
        int quadrat = 0;
        int kreis = 0;
        int kleeblatt = 0;
        int kreisMitPunkt = 0;
        int kreisMitKreuz = 0;

        stern = 0;
        while (stern < 10) {
            dreieck = 0;
            while (dreieck < 10) {

                raute = 0;
                while (raute < 10) {

                    int zahl1 = stern * 100 + dreieck * 10 + raute;

                    unendlich = 0;
                    while (unendlich < 10) {

                        dreieckAndersherum = 0;
                        while (dreieckAndersherum < 10) {

                            int zahl2 = unendlich * 100 + dreieck * 10 + dreieckAndersherum;
                            quadrat = 0;
                            while (quadrat < 10) {
                                int zahl3 = dreieckAndersherum * 100 + quadrat * 10 + quadrat;

                                if (zahl1 + zahl2 == zahl3)
                                    ;

                                {
                                    System.out.println(zahl3);

                                }

                                quadrat++;
                            }
                            dreieckAndersherum++;
                        }
                        unendlich++;
                    }
                    raute++;
                }
                dreieck++;
            }
            stern++;
        }

    }
}

So schaut das ganze doch gut aus ;-) Deine "quadrat++" als Beispiel sind in diesem Fall die Increments, die du IN der Schleife hast. Passt doch 😉

 

[L0oNY]

Will der Prof tatsächlich, dass die for Schleifen durch While Schleifen ersetzt werden?
Spontan würde ich behaupten, dass er die Verschachtelung ganz weg haben will

 

[Beginner2510]

Wir dürfen bisher nur While schleifen nehmen, weil wir For-Schleifen noch nicht in der Vorlesung hatten.

 

[mihe7]

Wir dürfen bisher nur While schleifen nehmen, weil wir For-Schleifen noch nicht in der Vorlesung hatten.

@L0oNY meinte, ob Du einfach nur die Schleifen ersetzen oder nicht auch die Verschachtelung der Schleifen entfernen sollst.

 

[Beginner2510]

Nur ersetzen.

 

[mihe7]

Na, dann 🙂 Wäre aber eine Aufgabe, die Du Dir selbst antun könntest...