4 stelliges Passwort aus bestimmten Zeichen.

[lostInSpaceSendHelp]

Hallo, ich bin noch Anfänger und mache derzeit eine Übung bei der ich einfach nicht weiter komme. Ich soll Passwörter knacken. Ich soll das Passwort generieren und dann einen Code schreiben um das Passwort zu finden und zu ermitteln wie oft geraten wurde um dieses Passwort zu finden. Im ersten Schritt soll ich mir alle möglichen Passwörter anzeigen lassen. Das Passwort soll 4 Stellig sein und darf nur die folgenden Zeichen enthalten: ABCabc012!. Ich brauchen einen Algorithmus der mir von AAAA bis !!!! alle Möglichkeiten anzeigt und in weiterer Folge ein zufälliges Passwort daraus erzeugt und mit Hilfe einer Schleife 1000 mal durch laufen lässt und dann ermittelt wie oft im Durchschnitt geraten wurde. Ich hoffe jemand kann mir helfen und die Angabe ist halbwegs verständlich.

 

[KonradN]

Und wie immer:

Kannst Du das denn machen? Sprich; Kriegst Du es hin, alle 4-stelligen Kombinationen aus diesen Zeichen zu bilden?
Wie gest Du dabei vor?

Es ist immer das gleiche Vorgehen: Erst muss man den Algorithmus verstehen. Das geht am einfachsten, in dem man es durchspiel. Wie kriegt man es selbst hin, diese Aufgabe zu erledigen?

Erst danach kann man anfangen, irgend einen Code zu schreiben.

 

[lostInSpaceSendHelp]

Und wie immer:

Kannst Du das denn machen? Sprich; Kriegst Du es hin, alle 4-stelligen Kombinationen aus diesen Zeichen zu bilden?
Wie gest Du dabei vor?

Es ist immer das gleiche Vorgehen: Erst muss man den Algorithmus verstehen. Das geht am einfachsten, in dem man es durchspiel. Wie kriegt man es selbst hin, diese Aufgabe zu erledigen?

Erst danach kann man anfangen, irgend einen Code zu schreiben.

Hallo,

Genau das ist mein Problem, ich steh total auf dem Schlauch was das betrifft. Wie kann ich aus diesen Zeichen nur 4 Werte nehmen und die auch noch random? Soll ich die Zeichen als String oder als char Array nehmen? und wie geht es weiter? Bin schon etwas verzweifelt.

 

[mihe7]

Wie kann ich aus diesen Zeichen nur 4 Werte nehmen und die auch noch random?

Spielt erstmal keine Rolle, denn zunächst sollst Du ja

Ich brauchen einen Algorithmus der mir von AAAA bis !!!! alle Möglichkeiten anzeigt

lösen. Im Algorithmus musst Du nicht wissen, wie das in einer Sprache kodiert wird.

 

[lostInSpaceSendHelp]

Spielt erstmal keine Rolle, denn zunächst sollst Du ja

lösen. Im Algorithmus musst Du nicht wissen, wie das in einer Sprache kodiert wird.

Ok aber wie soll ich denn nun diesen Code schreiben wenn ich denn nicht weiß wie das gehen soll?

 

[Wuast]

Der Tipp bisher war, nicht beim Code anzufangen, wenn du noch nicht weißt, wie du das Problem lösen könntest.

Alle Möglichkeiten der Kombinationen aus ABCabc012! mit 4 Zeichen sind potenzielle Lösungen. Du musst also jede Möglichkeit einmal durchgehen und diese Möglichkeit mit dem gesetzten Passwort abgleichen.
Die Empfehlung lautet, zunächst mal anzufangen, wie du das machen würdest, wenn du das ohne Code lösen müsstest. Du fängst also an, Kombinationen durchzuprobieren.

AAAA AAAa AAaA AaAA aAAA AAaa AaaA ... aaaa - also Alle Möglichkeiten mit A und a. Ist etwas dabei, kannst du aufhören. Falls nicht, gehts weiter.
AAAB ... aaab
AAAC ... aaac

BBBB BBBb BBbB ...

AAA! AA!A A!AA ... aaa! aa!a a!aa !aaa

und so weiter, bis du irgendwann beim !!!! angekommen bist.

Du wiederholst (das Kombinieren von Abfolgen aus einer Liste von Zeichen) solange (in einer Schleife), bis eine Abbruchbedingung erreicht ist. Und wenn du klar hast, was du wiederholst, kannst du das versuchen in einen Code zu schreiben.

Ich hoffe, die Experten (z.B. @KonradN und @mihe7 ) schauen nochmal rein, um eventuelle Exceptions meiner Hirnwindungen abzufangen

 

[MarvinsDepression]

Bei konkret dieser Aufgabe (exakt 10 verschiedene Symbole) läßt sie gerade die erste Teilaufgabe noch viel einfacher umsetzten. Jedem Symbol aus "ABCabc012!" läßt sich eine Ziffer zuordnen: Ein vierstelliges Passwort ließe sich dann eben als vierstellige Dezimalzahl codiert darstellen.
Um alle möglichen Kombinationen aufzulisten, genügt es, die Zahlen 0 bis 9999 wieder zu decodieren.

Der Code wird allerdings deutlich unflexibler und auch der Lerneffekt fällt geringer aus, aber als "Zuckerl" eine nette Freißaufgabe.

 

[mihe7]

Ok aber wie soll ich denn nun diesen Code schreiben wenn ich denn nicht weiß wie das gehen soll?

Ganz allgemein: indem Du einen Zettel und einen Stift in die Hand nimmst, um die Aufgabe zu lösen (s. das Beispiel von @Wuast). Dabei schaust Du Dir genau an, was Du in welchem Schritt gemacht hast, formulierst das und dann kannst Du anfangen, Code zu schreiben.

Ggf. fallen Dir dann auch Dinge auf, wie sie @MarvinsDepression genannt hat. Das Prinzip lässt sich für jede beliebige Anzahl von Symbolen verallgemeinern.

 

[Wuast]

also ich habe es ohne das Hin- und Rückcodieren in Dezimalzahlen gelöst - was mir dabei aber nicht schön gelingt, ist die Buchstaben bei der Eingabe des PW auf die vorgegebenen Zeichen zu beschränken. Dass mündet bei mir in einer ziemlich unschönen Anweisung mit vielen " || " ...
Hier freue auch ich mich kurz über einen Tipp, wie man das elegant lösen kann, gerne auch per PN wenn es hier nicht passt.

 

[KonradN]

Mir ist wichtig, dass die generelle Herangehensweise verstanden wird. Und da ist es tatsächlich so, dass man den Algorithmus als erstes verstehen muss. Was passiert wann? Das geht am Besten mit Stift und Papier (oder im Team am Whiteboard!). Dabei ist es egal, auf welchem Level man ist: Auch Senior oder Lead Developers machen das nicht anders. (Nur eben steigt da das Level, ab dem das gemacht wird. So kleinere Dinge hat man auf Grund der Erfahrung direkt im Kopf und muss es nicht durchspielen. Aber die Probleme werden ja immer komplexer...)

Da hilft dann auch ein Hilfmittel: Vereinfachung!

Auf dem Stift und Papier kannst Du das Problem erst einmal vereinfachen um es langsam zu verstehen. So spielt es für die generelle Lösung kein Thema, ob es nun 2, 3 10, 100, 1000, 100000 Zeichen sind, die im Alphabet vorkommen.

Daher kann man das tatsächlich mit weniger Zeichen aufschreiben, also nimm nur das Alphabet: a, b, c.
Und dann fang mit 1 Zeichen an. Kannst Du alle Kombinationen aufschreiben aus diesen drei Zeichen der Länge 1?
Wenn du das geschafft hast: Mach es mit der Länge 2 - kannst Du da alle Kombinationen aufschreiben?
Dann mit Länge 3 - siehst Du schon, wie Du vorgehen kannst? Wie ist das prinzipielle Vorgehen?

Durch dieses Ausprobieren solltest Du merken:
Bei einem Zeichen gehst Du einfach alle Zeichen durch.
a
b
c

Das ist also einfach eine Schleife:

Für jedes Zeichen:
- schreibe das Zeichen

Bei Zwei Zeichen gehst Du für jede Stelle alle Zeichen durch:
aa
ab
ac
ba
bb
bc
...

Du erkennst also: Für jedes erste Element gehst Du noch einmal alle Elemente für das zweite Zeichen durch. Du hast also zwei mal die Schleife wie schon angegeben - und zwar ineinander:

Für jedes Zeichen:

• schreibe das Zeichen
• für jedes Zeichen

-- schreibe das Zeichen

Was man jetzt beim Durchspielen aber merkt: Da fehlt noch der Zeilenumbruch. Der muss nach dem letzten Zeichen geschrieben werden, also eigentlich ist es ein:

Für jedes Zeichen:
- schreibe das Zeichen
- für jedes Zeichen
-- schreibe das Zeichen
-- schreibe ein Zeilenumbruch

Das wird übrigens auch schneller deutlich, wenn man als Ziffern nur Zahlen verwendet. Das ist das, was man schon gewohnt ist. Also z,B, nur 0 und 1:
000000
000001
000010
000011
000100
...


Das mit dem Kodieren und Dekodieren kann man sich auch überlegen. Aber das kann man über zwei Refactorings machen und ist unabhängig von der Anzahl der Zeichen.

Ich habe x Schleifen, die von 0 bis n gehen. Das sind dann in der innersten Schleife n^x elemente. (mit 10 Elementen ist es deutlich: eine Stelle: 10^1 = 10, bei zwei sind es 10^2=100 und es ist ja von 00 - 99 genau 100 ... bei 3 sind 1000 u.s.w.

Also kannst Du die einzelnen Stellen immer bekommen mit zaehler / n^Stelle % n

Also nehmen wir ein Beispiel im 10er System: 12345
Stelle 0 ist die 5 denn 12345 / 10^0 % 10 = 5
Stelle 1 ist die 4 denn 12345 / 10^1 % 10 = 4
Stelle 2 ist die 3 denn 12345 / 10^2 % 10 = 3
...

Aber braucht man das Refactoring zu einer Schleife? Ich denke nicht. Wenn bei so einem Algorithmus die große Anzahl Schleifen stört, dann wäre halt die Rekursion eher ein Variante. Dann gibt es nur eine Schleife und so lange die Anzahl Stellen nicht erreicht wird, wird dann noch eine Ziffer angehängt.

Das nur noch einmal um zu verdeutlichen, was genau von Dir verlangt war! Bitte vollziehe das im Detail nach! Spiel es wirklich durch! Genau diese Vorgehensweise musst Du begreifen! So und nicht anders kannst Du Aufgaben lösen.

 

[Neumi5694]

Ok aber wie soll ich denn nun diesen Code schreiben wenn ich denn nicht weiß wie das gehen soll?

Zuerst verstehen wie's gehen soll, dann in Code umsetzen.
Programmieren, ohne zu wissen, was der Code eigentlich machen soll, führt nicht zum Ziel.

Du weißt doch, wie du ein Zahlenschloss durch Durchprobieren knacken würdest, oder? Das hier ist genau das Gleiche, nur eben mit einer Stelle mehr und mehr Zeichen.
Versuche mal, deine Vorgangsweise für das Zahlenschloss zu beschreiben. Nicht mit "alle Kombinationen ausprobieren", sondern beschreibe, wie man überhaupt zu diesen Kombinationen überhaupt.
Wenn du das sauber formulieren kannst, dann kannst du daraus direkt den Code ableiten. Aber zuerst muss du eben erst mal diese Formulierung schaffen, sonst wird das nichts mit Programmieren und du solltest Fachrichtung wechseln.

 

[lostInSpaceSendHelp]

Also beim knacken des PW hab ich schon einen Pseudocode geschrieben. Ich würde die die möglichen Zeichen, also den String (vermutlich mit einer Schleife) durchgehen bis das die Kombination die selbe wie das Passwort ergibt. Was mir wirklich Schwierigkeiten bereitet ist wie ich aus diesem String, random Wert raus ziehen soll bzw nur 4 Stellen generieren soll. Ich habe ähnliche Sachen schon mit Int Werten gemacht und hätte jetzt versucht evtl den String in int um zu wandeln oder mit der ASCII Tabelle zu rechnen. Allerdings bekomme ich immer nur eine 4 Stellige Möglichkeit angezeigt. Ich möchte aber alle 4 Stelligen Möglichkeiten ausgeben und das ist für mich gerade unbegreiflich.

 

[KonradN]

In #10 habe ich doch eigentlich schon gegeben, wie man alle Möglichkeiten durchgehen kann. Evtl. schaust Du Dir das dort geschriebene noch einmal im Detail an und gehst dann evtl. darauf ein, was Du da nicht verstehst? (Bis zu dem Punkt "Das mit dem Kodieren und Dekodieren kann man sich auch überlegen." - Ab dem Bereich geht es mehr um das, was @MarvinsDepression geschrieben hat.)

Das Problem wäre im Augenblick, dass ich da sonst nur alles wiederholen würde und erneutes Wiederholen wird vermutlich nichts bringen. Wenn man aber Hinweise hat, an welcher Stelle es genau Probleme gibt, dann könnte man da gezielt versuchen, es detailierter oder mit anderen Worten zu erläutern.

 

[temi]

Die Aufgabe ist ja zweiteilig. Zuerst sollt du ein zufälliges Passwort erstellen, dann mittels Brute-Force (alle möglichen Kombinationen durchgehen) ermitteln welches das Passwort gewesen ist.

Zum zweiten Teil wurde schon einiges geschrieben und du musst da wirklich nur ein PW nach dem anderen erstellen und mit dem Gesuchten vergleichen bis du es gefunden hast.

Zum zufälligen Erstellen gilt wie schon oft geschrieben: Denk darüber nach, wie du es "von Hand" machen würdest, z. B. kannst du die die 10 Zeichen des PW-Alphabets der Reihe nach aufschreiben, dann nimmst du einen zehnseitigen Würfel und würfelst vier mal. Wird die 3 gewürfelt, dann nimmst du das Zeichen an der dritten Stelle, usw.

Das musst du jetzt nur noch in Code fassen...

 

[lostInSpaceSendHelp]

ok danke für eure Hilfe, ich glaube ich bin ein bisschen weiter gekommen da ich jetzt mit for Schleifen zumindest mal 4 Stellige Kombinationen generieren konnte. Allerdings bekomme ich nur 10 Möglichkeiten angezeigt weil ich von der Stringlänge ausgehe. Ich möchte aber alle Möglichkeiten anzeigen lassen. Ich denke eine do while Schleife wäre hier am besten aber welche Abbruchbedingung müsste ich nehmen? Brauche ich überhaupt 4 for Schleifen?

String alphabet = "ABCabc012!";
        char pw[] = alphabet.toCharArray();

        
        for (int i = 0; i <= alphabet.length(); i++) {
            for (int j = 0; j <= alphabet.length(); j++) {
                for (int k = 0; k <= alphabet.length(); k++) {
                    for (int l = 0; l <= alphabet.length(); l++) {

                        System.out.println(pw[i] + " " + pw[j] + " " + pw[k] + " " + pw[l]);
                    }
                }
            }
        }

 

[KonradN]

Allerdings bekomme ich nur 10 Möglichkeiten angezeigt weil ich von der Stringlänge ausgehe.

Du bekommst nur 10 Zeilen ausgegeben, weil Dann eine Exception kommt. Deine Schleifenbedingungen sind schlicht falsch.

Wie läufst Du über ein Array? Was ist der erste index? Was ist der letzte Index? Wann muss man also die Schleife abbrechen?
Die Fehlermeldung sagt es ja prinzipiell auch schon: "java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 10"

Brauche ich überhaupt 4 for Schleifen?

Du brauchst die nicht zwingend. Wie es auch gehen könnte wurde ja im Thread auch etwas beleuchtet. Aber Du hast ja bereits eine funktionierende Lösung die so auch gut lesbar ist. Nur eben ein kleiner Fehler hat sich eingeschlichen, weshalb Dein Code so nicht funktioniert.

 

[no00nerd]

Hallo @lostInSpaceSendHelp Ich hätte es (ohne Mischen) glatt so gemacht:

public class Passwort {
    private final static int passwortLaenge = 3;
    private final static char[] erlaubteZeichen = {'a', 'b', 'C', 'D'}; // must be multiple of 2 power n, eg 1,2,4,8,...
    private final static int seed = 4;
    private final int len = 15;
    private final boolean[] bits;
    private final int[] t = {14, 15};

    public Passwort() {
        bits = new boolean[len + 1];
        for (int i = 0; i < len; i++) {
            bits[i] = (((1 << i) & seed) >>> i) == 1;
        }
    }

    public short nextShort() {
        short next = 0;
        for (int i = 0; i < len; i++) {
            next |= (bits[i] ? 1 : 0) << i;
        }
        next--;

        bits[len] = false;
        for (int j : t) {
            bits[len] ^= bits[len - j];
        }
        for (int i = 0; i < len; i++) {
            bits[i] = bits[i + 1];
        }
        return next;
    }


    public String getNextString() {
        String next = "";
        int len2 = (int) Math.ceil(Math.log10(erlaubteZeichen.length) / Math.log10(2));
        int len3 = (int) Math.pow(erlaubteZeichen.length, passwortLaenge);
        short s;
        do {
            s = nextShort();
        } while (s >= len3);

        for (int i = 0; i < passwortLaenge; i++) {
            int k = 0;
            for (int j = i * len2, j2 = 0; j < (i + 1) * len2; j++, j2++) {
                k |= ((s >> j) & 1) << j2;
            }
            next += erlaubteZeichen[k];
        }
        return next;
    }

    public static void main(String[] args) {
        Passwort pw = new Passwort();
        for (int i = 0; i < 64 + 10; i++) {
            System.out.println(pw.getNextString());
        }
    }
}

das sollte schon helfen, zum Vertiefen: linear-feedback shift register (LFSR)

 

[KonradN]

das sollte schon helfen

Das ist Dein ernst? Schon der Kommentar im Code, dass die Anzahl der erlaubten Zeichen eine Anzahl haben soll, die einer Zweierpotenz entspricht macht deutlich, dass die Aufgabe nicht gelesen wurde: Es sind 10 vorgegebene Zeichen erlaubt.

Und die unnötige Komplexität muss man gar nicht erst ansprechen denke ich.

Aber evtl. kann der TE ja sagen: war der Code hilfreich?

 

[no00nerd]

Was findest du denn zu kompliziert? Die Frage oder meine Antwort?

Und 2^10*4 ist ja eine Zweipotenz...

Ich weiß, Mathe kann manchmal ärgerlich sein...

 

[KonradN]

Ja danke, war ja klar, dass es eine Tobias Antwort war.

Wollen wir wirklich einmal darauf im Detail eingehen? Da die Moderatoren / Admins vermutlich einfach den Account samt Beiträgen löschen werden wird die Antwort dann alleine da stehen... das ist ärgerlich, aber ok, muss man es etwas deutlicher machen.

a) Tobias hat einen pseudo Zufallsgenerator geschrieben statt den von Java zu verwenden. Da er aber keine dynamische Initialisierung hat, erzeugt sein Code immer die gleichen Passwörter. Bei jedem Aufruf seines Codes kommen also immer genau die gleichen Passwörter (Bei seinem Code halt immer Daa, baa, ...

b) Sein Code setzt voraus, dass die Anzahl der erlaubten Zeichen eine Zweierpotenz sind. Es ist in der Aufgabe aber vorgegeben, welche Zeichen erlaubt sind und das sind 10 Zeichen. Das war dewr Hinweis von mir in meiner ersten Antwort. Hat Tobias aber leider nicht verstanden. Liegt vermutlich daran, dass er da einfach Code kopiert hat ohne ihn zu verstehen. Wobei das relativ einfach zu verstehen gewesen wäre, denn der kopierte Code hat das ja als Kommentar sogar drin stehen:
private final static char[] erlaubteZeichen = {'a', 'b', 'C', 'D'}; // must be multiple of 2 power n, eg 1,2,4,8,...

Das man das im Code ggf. nicht sieht, mag ja sein. Aber dann würde man es halt einmal ausprobieren. Also z.B. ein weiteres Zeichen hinzu fügen, z.B. das 'E':
private final static char[] erlaubteZeichen = {'a', 'b', 'C', 'D', 'E'}; // must be multiple of 2 power n, eg 1,2,4,8,...
um es dann zu testen:

Daa
baa
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 7 out of bounds for length 5
    at AppModule/de.kneitzel.Passwort.getNextString(Passwort.java:50)
    at AppModule/de.kneitzel.Passwort.main(Passwort.java:58)

Ansonsten könnte man noch auf Bezeichner eingehen und so - aber das sparen wir uns einfach einmal.


Was bleibt ist halt, dass hier in erster Linie ein Code für einen pseudo Zufallsgenerator gebaut wurde und dieser dann genutzt wurde um zufällige Zeichen auszuwählen. Die Auswahl wurde dabei dann so gewählt, dass es da leider gewisse Zwänge gibt - wie z.B. die Begrenzung mit der Anzahl der Zeichen.

Die Frage, die sich da dann natürlich stellt: Wenn man die Texte des TE liest: Wie kommt man auf die Idee zu glauben, dass dies hilfreich ist? Wo der Code offensichtlich nicht funktioniert mit den klaren Vorgaben (Alphabet aus 10 Zeichen!),

Unter dem Strich ist es also wieder einmal eine typische Aktion von Tobias: Es wird ein Stück überkomplizierter Code gebracht. Meiner Meinung nach vermutlich um zu zeigen, was für ein toller Entwickler er ist. Da aber die Anforderungen nicht verstanden wurden (vermutlich nicht einmal richtig gelesen) ist dann leider etwas heraus gekommen, dass für den TE in keiner Weise hilfreich sein dürfte. Zumal es in erster Linie wie immer hingeworfener Code ist. Erklärungen sind nun einmal nicht sein Ding.

 

[no00nerd]

Hhm, das ist nicht nachvollziehbar. Von wo soll wer was wie kopiert haben?

Und warten wir doch einfach die Antwort vom TE ab, ob er deine Antwort so nenne ich das jetzt mal als nützlich empfindet oder eher nicht so.

 

[temi]

Und warten wir doch einfach die Antwort vom TE ab

@lostInSpaceSendHelp empfehle ich, deine Antwort einfach zu ignorieren. Selbst wenn es sich um eine sinnvolle Methode handeln würde, wäre sie für einen Anfänger nicht brauchbar.

 

[KonradN]

Hhm, das ist nicht nachvollziehbar. Von wo soll wer was wie kopiert haben?

Das weiss ich nicht und es interessiert mich auch nicht. Ich habe meine Meinung gesagt und diese mit klaren Argumenten versehen.

So eine Vermutung liegt aber nahe, denn wäre der Code frisch entstanden, dann wäre Dir der Kommentar im eigenen Code deutlich bewusster gewesen. Das ist aber prinzipiell egal - der Code ist für die Aufgabenstellung unbauchbar auf Grund technischer Einschränkungen. Und für Anfänger absolut uninteressant. Das müsste Dir eigentlich auch klar sein. Daher ist Dein Auftreten einfach eine Provokation. Du willst halt der Forentroll sein und daher wird der Account in Kürze weg sein. Daher ist eine weitere Auseinandersetzung schlicht sinnlos.

 

[no00nerd]

pseudo Zufallsgenerator geschrieben statt den von Java zu verwenden

Das ist kein PRNG... Zufallszahlen wiederholen sich manchmal. Und Java hat leider keinen LFSR dabei.

Aber ich bin mir sicher, das ist dir alles längst bekannt...

 

[KonradN]

Das ist kein PRNG.

Also klären wir erst einmal den Begriff für Dich:

Was sind Pseudozufallszahlen? Bzw. ein Pseudozufallsgenerator?
"Die Bezeichnung „Pseudo“zufallszahlen kommt daher, daß diese Zahlen durch deterministische Formeln erzeugt werden, also nicht wirklich zufällig sind. Die Formeln, nach denen Pseudozufallszahlen erzeugt werden, heißen Zufallszahlengeneratoren."

Pseudozufallszahlen

Folge von computergenerierten Zahlen, die einer zufälligen Zahlenfolge möglichst ähnlich ist. Genauer: Die Folge soll sich so verhalten, als…

www.spektrum.de

Und Du hast eine klare Initialisierung von Werten und darauf basierend klare Berechnungen. Daher hast Du bei jedem Aufruf genau die gleichen Werte.

Bei deinem Programm kommt also immer das Ergebnis:

Daa
baa
DDC
Dbb
DCa
bba
DbC
Dab
bCa
DCD
bDb
baC
CDC
Cbb
CCa
aba
DbD
DCb
bDa
DaC
bab
bbD
CaD
aCb
bCC
CbC
Cab
aCa
DaD
bCb
bDC
aDD
CaC
aab
baD
CCC
abb
bDD
aCD
CbD
CCb
aDa
DCC
bbb
bCD
aaC
abC
aDC
CCD
aDb
bbC
aaD
abD
aCC
CDD
CDb
CDa
Cba
Caa
aaa
DDD
DDb
DDa
Dba
Daa
baa
DDC
Dbb
DCa
bba
DbC
Dab
bCa
DCD

Das hat also nichts mit "Zufallszahlen wiederholen sich" zu tun sondern einfach damit, dass Du auf immer den gleichen Zahlen die gleichen mathematischen Operationen ausübst.

Darf ich also daraus ableiten, dass Du nicht nur keine Ahnung hast, was der von dir gebrachte Code macht sondern Du hast die Bauteile, die Du offensichtlich kopiert hast, nicht einmal ansatzweise verstanden?

 

[Wuast]

Reicht nicht auch einfach

public void codeCracking(String pw) {        //hier wird das gesetzte PW übergeben
        System.out.print("Password: ");
        String password = pw;
        char [] digits = pwMng.getDigits();        //ruft den Array mit den erlaubten Zeichen auf
        for (int j = 0; j < password.length(); j ++ ) {
            for (int i = 0; i < digits.length; i++) {
                if (password.charAt(j) == digits[i])  {
                    System.out.print(password.charAt(j));
                }
            }
        }
    }

?
Verstehe gerade die Diskussion nicht mehr so richtig

 

[mihe7]

Verstehe gerade die Diskussion nicht mehr so richtig

Es geht noch um den ersten Teil, alle möglichen Passwörter auszugeben.

Zu Deinem Code: nette Idee, nur dann könnte man auch schreiben:

public void codeCracking(String pw) {      
    System.out.print("Password: " + pw);
}

 

[Wuast]

xD ja stimmt natürlich, das war ein bisschen blödsinnig. dann ohne die if-abfrage.
vllt hatte ich die Aufgabenstellung auch nicht richtig im Kopf

edit: habe nochmal geschaut. hab gar nicht richtig gelesen was gefordert wurde. Hauptsache ich hab meinen Senf dazu gegeben