Another Schleifenproblem

[trekker99]

Hallo Leute,

hänge mal wieder an einer Anfängerübung fest 😅

Ich will, dass die Suche nach einem 3-stelligen Passwort ausgegeben wird und bei der richtigen Kombination stehen bleibt.
Die Ausgabe aller Varianten funktioniert soweit, ich bekomm es aber nicht hin, dass beim richtigen Ergebnis abgebrochen wird.
Idee war, das mit einer do-while-Schleife zu lösen, also gib alle Kombinationen aus, bis es die richtige ist und bleib stehen.

Schonmal recht herzlichen Dank!

public class test {

    public static void main(String[] args) {

        String pass = "1!6";

        char[] passArray = pass.toCharArray();

        char symbols[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '?', '.', ','};

        for (int i = 0; i < symbols.length; i++ ) {

            for (int j = 0; j < symbols.length; j++) {

                for (int k = 0; k < symbols.length; k++) {

                    char crackArray[] = {symbols[i], symbols[j], symbols[k]};

                    do {
                        System.out.print(symbols[i]);
                        System.out.print(symbols[j]);
                        System.out.print(symbols[k]);
                        System.out.println();
                    } while (crackArray == passArray);
                }
            }
        }
    }
}

 

[Oneixee5]

Arrays von primitiven Datentypen vergleicht man mit Arrays.equals. So wirst du sehen das dein Vergleich nicht funktioniert.

        System.out.println(new char[] {'a','a'} == new char[] {'a','a'});
        System.out.println(Arrays.equals(new char[] {'a','a'}, new char[] {'a','a'}));
        System.out.println(Arrays.equals(new char[] {'a','a'}, new char[] {'a','b'}));

 

[Oneixee5]

Eine Schleife kann man vorzeitig mit break; verlassen. Besser wäre es aber die Schleifen beim Eintreffen einer Bedingung regulär zu beenden.

 

[kneitzel]

Arrays vergleicht man mit Arrays.equals

Alternativ kann man auch einfach alle drei Elemente vergleichen. Dann braucht man keinerlei spezielle Klassen / Methoden. (Vermutlich ist das am Anfang auch eher Ziel der Übung - mehrere Bedingungen abfragen ...)

                    do {
                        System.out.print(symbols[i]);
                        System.out.print(symbols[j]);
                        System.out.print(symbols[k]);
                        System.out.println();
                    } while (crackArray == passArray);

Hier solltest Du erst einmal formulieren, was Du überhaupt machen willst. Das der Vergleich so nicht korrekt ist, ist ja schon behandelt worden. Aber ich glaube nicht, dass Du im Falle dass das Passwort gefunden wurde dieses in einer Endlosschleife ausgeben möchtest. Daher sagt erst einmal in Worten, was da passieren soll!

 

[trekker99]

@Oneixee5 danke für den Tipp, die Info hat mir noch komplett gefehlt! Dachte ich hab einfach nur etwas anderes falsch gemacht, da das Programm das so grundsätzlich nicht als falsch markiert hat ^^

@kneitzel dir auch wieder danke! Das ist jetzt auch schon mein nächstes großes Fragezeichen, nämlich wie man in so einem Fall dann die Bedingung erhöhen kann damit die Schleife auch endet!?
Es sollen so lange die Ergebnisse der Schleifen ausgegeben werden, bis das Ergebnis mit der Eingabe übereinstimmt. Dann soll die Schleife enden.

 

[kneitzel]

Die wichtige Frage ist doch, was Du da genau machen willst.

Typische Formulierungen sind hier dann etwas wie:
- Wenn eine Bedingung erfüllt ist, dann mache dieses und jenes.
- So lange etwas erfüllt ist, mache dieses und jenes.
- Mache dieses und jenes und wenn eine Bedingung erfüllt ist, wiederhole etwas.

Bei Deiner Aussage musst Du etwas trennen: "Es sollen so lange" ist ja die Schleife außen....

Damit bleibt:
- Es soll das Zwischenergebnis ausgegeben werden.
- Wenn das Zwischenergebnis mit der Eingabe übereinstimmt, dann soll die Schleife enden.

Der erste Punkt entspricht dem Code, den Du derzeit in der do while Schleife hast. Also muss diese do while Schleife nur weg und der Inhalt muss so da stehen.
"die Schleife" ist ungenau - du hast ja 3 Schleifen! eine Schleife kannst Du mit break verlassen - aber du willst ja alle 3 verlassen.
- Das ginge z.B. mit einem Label - aber das ist eine Form der Entwicklung, die ich ablehne. (Auch wenn eine Person hier im Forum das zu lieben scheint)
- Du könntest die Schleifenvariablen alle auf einen Wert setzen, der so hoch ist, dass die Schleifen alle verlassen werden. Lehne ich auch ab.
- du könntest das auslagern in eine Methode. Dann kannst Du die Methode mit einem return verlassen.

 

[trekker99]

Ok, dann scheint das mit den Mitteln die ich derzeit habe, so wie ich das will, nicht umsetzbar zu sein. Werde mir das Thema Methoden mal ansehen, aber gefragt ist ohnehin nur die Ausgabe des korrekten Ergebnisses. Was hältst du von folgender Umsetzung?

import java.util.Arrays;

public class Password {

    public static void main(String[] args) {

        String pass = "9!9?";

        char[] passArray = pass.toCharArray();

        char symbols[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '?', '.', ','};

        System.out.println();
        System.out.print("Das Passwort lautet ");

        for (int i = 0; i < symbols.length; i++ ) {

            for (int j = 0; j < symbols.length; j++) {

                for (int k = 0; k < symbols.length; k++) {

                    for (int l = 0; l < symbols.length; l++) {

                        char crackArray[] = {symbols[i], symbols[j], symbols[k], symbols[l]};

                        while (Arrays.equals(crackArray, passArray)) {
                            System.out.print(symbols[i]);
                            System.out.print(symbols[j]);
                            System.out.print(symbols[k]);
                            System.out.print(symbols[l]);
                            System.out.println();
                            if (Arrays.equals(crackArray, passArray)) {
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
}

 

[kneitzel]

Was macht denn ein

while (Bedingung) {
    // Irgendwas, das an Bedingung nichts ändert
    if (Bedingung) break;
}

Das funktioniert zwar, aber das macht so dennoch wenig Sinn

 

[trekker99]

Mhm, ok, ja das if macht da nicht viel Sinn.
In der Hitze des Gefechts und mit dem Zeitdruck kommen dann solche Sachen raus 😅

 

[X5-599]

Wenn du das jetzt noch korrigierst bist du doch schon quasi fertig.

 

[mihe7]

Ok, dann scheint das mit den Mitteln die ich derzeit habe, so wie ich das will, nicht umsetzbar zu sein.

Doch. Du siehst aber, dass geschachtelte Schleifen für jede "Stelle" des Passworts nicht besonders praktisch sind. Also könntest Du Dir etwas anderes überlegen.

 

[trekker99]

@kneitzel recht herzlichen Dank! 😊

@X5-599 ja, hab das Beispiel jetzt auch vorerst so mal für beendet erklärt

@mihe7 interessanter Hinweis! Leider kann ich mir für die einzelnen Beispiele nicht alle Zeit der Welt nehmen um sie weiter zu vertiefen, das ist in dem Kurs den ich besuche einfach nicht drin. Dass Schleifen manchmal auch eher hinderlich als dienlich sein können hab ich nun schon öfter bemerkt, auch bei dem nächsten Beispiel an dem ich jetzt gerade dran bin

 

[mihe7]

Leider kann ich mir für die einzelnen Beispiele nicht alle Zeit der Welt nehmen um sie weiter zu vertiefen, das ist in dem Kurs den ich besuche einfach nicht drin. Dass Schleifen manchmal auch eher hinderlich als dienlich sein können hab ich nun schon öfter bemerkt, auch bei dem nächsten Beispiel an dem ich jetzt gerade dran bin

Es geht nicht um die Schleifen an sich sondern um deren Verwendung: Dein Code ist zu spezifisch.

Die Überlegung ist eigentlich genau die gleiche, wie man ein Zahlenschloss "knackt". Man stellt alle Zahlen auf 0 und beginnt dann damit, zu probieren, ob das Schloss aufgeht. Wenn nicht, dann dreht man das erste Rädchen weiter. Wenn man mit dem Rädchen wieder zur 0 kommt, dreht man das nächste Rädchen weiter. Wenn man mit diesem zur 0 kommt, dreht man wiederum das nächste Rädchen weiter usw. Ansonsten probiert man wieder, ob das Schloss aufgeht und dreht wieder am ersten Rädchen.

Etwas formaler:

Sei n die Länge des Passworts (z. B. n = 3)
Erzeuge das Passwort k, das das erste Symbol n-mal enthält (z. B. 000)
So lange k nicht das gesuchte Passwort ist, wiederhole {
    Sei r := -1
    wiederhole {
        r := r + 1
        Setze in k an Position r das Folgesymbol
    } so lange an Position r das erste Symbol steht
}

 

[trekker99]

Es geht nicht um die Schleifen an sich sondern um deren Verwendung: Dein Code ist zu spezifisch.

Die Überlegung ist eigentlich genau die gleiche, wie man ein Zahlenschloss "knackt". Man stellt alle Zahlen auf 0 und beginnt dann damit, zu probieren, ob das Schloss aufgeht. Wenn nicht, dann dreht man das erste Rädchen weiter. Wenn man mit dem Rädchen wieder zur 0 kommt, dreht man das nächste Rädchen weiter. Wenn man mit diesem zur 0 kommt, dreht man wiederum das nächste Rädchen weiter usw. Ansonsten probiert man wieder, ob das Schloss aufgeht und dreht wieder am ersten Rädchen.

Etwas formaler:

Sei n die Länge des Passworts (z. B. n = 3)
Erzeuge das Passwort k, das das erste Symbol n-mal enthält (z. B. 000)
So lange k nicht das gesuchte Passwort ist, wiederhole {
    Sei r := -1
    wiederhole {
        r := r + 1
        Setze in k an Position r das Folgesymbol
    } so lange an Position r das erste Symbol steht
}

Lustig, dass du das Beispiel mit dem Zahlenschloss bringst. Genauso hab ich mir das mit meinen verschachtelten Schleifen vorgestellt
Hab mir deinen Pseudocode mal rauskopiert und werde das bei Gelegenheit mal durchdenken.
Macht mich auf jeden Fall neugierig! Vielen Dank!