Alle Kombinationen von "0000" bis "FFFF" kompakt schrieben

[Gelöschtes Mitglied 67123]

Ich habe folgenden Code (erst mal nur bis FFFF):

static String[] letters = new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"};

    public static void main(String[] args) throws IOException {
        for (String first : letters) {
            for (String second : letters) {
                for (String third : letters) {
                    for (String fourth : letters) {

                        String sequence = first + second + third + fourth;
                        System.out.print(sequence);
                    }
                }
            }
        }
    }

Damit kann ich mir zwar alle Kombinationen ausgeben lassen, aber ich müsste für jede neue Stelle eine weitere for-loop erstellen, z. B. wenn es 10 Stellen haben soll.
Wie kann ich das kürzer schreiben und noch zusätzlich angeben, wie viele Stellen ich mit allen Kombinationen haben möchte?

 

[KonradN]

Das ist eine einfache Hexadezimale Zahl - es reicht also eine Schleife mit Ausgabe als Hexadezimal-Zahl:

        for (int zahl = 1; zahl <= 0xff ; zahl++)
            System.out.println(String.format("%2X", zahl));

Das ist jetzt für zwei Stellen - du kannst aber die Schleife anpassen und bei der Formatierung die %2x zu %4x oder so ändern.

 

[Gelöschtes Mitglied 67123]

Das ist eine einfache Hexadezimale Zahl - es reicht also eine Schleife mit Ausgabe als Hexadezimal-Zahl:

        for (int zahl = 1; zahl <= 0xff ; zahl++)
            System.out.println(String.format("%2X", zahl));

Das ist jetzt für zwei Stellen - du kannst aber die Schleife anpassen und bei der Formatierung die %2x zu %4x oder so ändern.

Erst mal danke, aber wie ist sieht es denn bei Strings aus? Das war in meinem Beispiel ausgerechnet Hexadecimal.
Zum Beispiel: "0000" bis "ZZZZZZZZZZZZ"
Mindestlänge 4, Maximallänge 12

 

[Robert Zenz]

Wie kann ich das kürzer schreiben und noch zusätzlich angeben, wie viele Stellen ich mit allen Kombinationen haben möchte?

Eine einfache for-Schleife von 0 bis Anzahl der Stellen sollte eigentlich vollkommen ausreichen, und darin dann die einzelnen Buchstaben ausgeben. Probier mal selbst ob du das hinbekommst (so als Hinweis, die von @KonradN ist schon eine gute Vorlage).

 

[KonradN]

Als zusätzlicher Hinweis: Du hast ja dann eine Zahl, die Du in einem bestimmten Zahlensystem darstellen willst. Wenn Du statt 10 oder 16 dann von mir aus 36 mögliche Ziffern hast, dann hast Du eine einfache Umwandlung einer Zahl in das "36er System". Damit kann man sich ja anschauen, wie man sowas rechnerisch durchführen kann.

 

[Gelöschtes Mitglied 67123]

Als zusätzlicher Hinweis: Du hast ja dann eine Zahl, die Du in einem bestimmten Zahlensystem darstellen willst. Wenn Du statt 10 oder 16 dann von mir aus 36 mögliche Ziffern hast, dann hast Du eine einfache Umwandlung einer Zahl in das "36er System". Damit kann man sich ja anschauen, wie man sowas rechnerisch durchführen kann.

Ich habe folgende Methode gefunden, musste sie mir aber lange anschauen:

for (int length = minLength; length < maxLength + 1; length++) {
            generate("", length);
}

        static void generate(String str, int length) {
        if (length == 0) {
            System.out.println(str);
        } else {
            for (char c : charset) {
                generate(str + c, length - 1);
        }
        }
        }

Trotzdem danke.

 

[Neumi5694]

Hexadezimal ist einfach.
Für einen beliebigen Wertebereich (auch mit Lücken und nicht mit fortlaufenden Zeichen) wäre der klassische manuelle Ansatz (ohne vorgefertigte Funktionen) eine rekursive Methode mit Zähler. Bei jedem rekursiven Aufruf wird der Zähler verringert, bis er 0 erreicht hat. Rückgabewet wäre jeweils eine Liste von Strings.

 

[Gelöschtes Mitglied 67123]

Hexadezimal ist einfach.
Für einen beliebigen Wertebereich (auch mit Lücken und nicht mit fortlaufenden Zeichen) wäre der klassische manuelle Ansatz (ohne vorgefertigte Funktionen) eine rekursive Methode mit Zähler. Bei jedem rekursiven Aufruf wird der Zähler verringert, bis er 0 erreicht hat. Rückgabewet wäre jeweils eine Liste von Strings.

Ich habe noch eingebaut, dass die Kombinationen in eine Datei geschrieben werden sollen. Jedoch besteht das Problem, dass z. B. für "0000" bis "FFFF" nur dann alle Kombinationen in die Datei geschrieben werden, wenn ich explizit ein Maximum für die Kombinationen festlege (bspw. max. 65.536 Kombinationen, was ja eigentlich auch ohne Angabe rauskommen sollte, tut es aber nicht).

            if (outputToFile) {
                writer.write(before + str + after + "\n");
            }

            if (printInConsole) {
                System.out.println(before + str + after);
            }

Liegt das irgendwie an FileWriter? Denn in der Konsole werden alle Kombinationen ausgegeben ...

 

[KonradN]

Wobei diese verschachtelten Schleifen / rekursive Aufrufe so nicht benötigt werden.

Eine einfache Zählschleife reicht aus. Und zu Darstellung kann man eine Schleife schreiben, die halt:
a) die aktuelle Ziffer mit % AnzahlZiffern
b) den Rest mit / AnzahlZiffern berechnet.
Und das so lange, bis der Rest 0 ist.

Das ist ganze Problem lässt sich also in zwei einfache Teilprobleme unterteilen:
1. Ein einfacher Zähler
2. Eine Darstellung einer Zahl.

 

[KonradN]

Ich habe noch eingebaut, dass die Kombinationen in eine Datei geschrieben werden sollen. Jedoch besteht das Problem, dass z. B. für "0000" bis "FFFF" nur dann alle Kombinationen in die Datei geschrieben werden, wenn ich explizit ein Maximum für die Kombinationen festlege (bspw. max. 65.536 Kombinationen, was ja eigentlich auch ohne Angabe rauskommen sollte, tut es aber nicht).

            if (outputToFile) {
                writer.write(before + str + after + "\n");
            }

            if (printInConsole) {
                System.out.println(before + str + after);
            }

Liegt das irgendwie an FileWriter? Denn in der Konsole werden alle Kombinationen ausgegeben ...

Die Problematik verstehe ich jetzt gerade nicht. Was ist denn die genaue Fehlersituation?

Und Du brauchst nicht ständig diese Abfragen. System.out ist ein PrintWriter und wenn Du bei der Datei auch einen Writer hast, dann kannst Du einfach etwas schreiben wie:

try (Writer writer = getWriter()) {
    // Dein Code mit eben dem Writer!
}




// ...
private writer getWriter() {
    if (writeToConsole) return System.out;
    if (writeToFile) return new FileWriter(....);
    throw new IllegalStateException("No Output defined");
}

Wichtig ist halt auch, dass so Dinge sauber geschlossen werden und da bietet sich in der Regel ein try with resources an. Hier evtl. nicht so gut, da Du System.out nicht schließen willst 🙂

 

[Gelöschtes Mitglied 67123]

Die Problematik verstehe ich jetzt gerade nicht. Was ist denn die genaue Fehlersituation?

Und Du brauchst nicht ständig diese Abfragen. System.out ist ein PrintWriter und wenn Du bei der Datei auch einen Writer hast, dann kannst Du einfach etwas schreiben wie:

try (Writer writer = getWriter()) {
    // Dein Code mit eben dem Writer!
}




// ...
private writer getWriter() {
    if (writeToConsole) return System.out;
    if (writeToFile) return new FileWriter(....);
    throw new IllegalStateException("No Output defined");
}

Wichtig ist halt auch, dass so Dinge sauber geschlossen werden und da bietet sich in der Regel ein try with resources an. Hier evtl. nicht so gut, da Du System.out nicht schließen willst 🙂

Wenn ich die getWriter()-Methode in Verwendung ziehen würde, würde sich IntelliJ um FileWriter und PrintStream streiten.

Jedoch funktioniert es jetzt wieder ... plötzlich. Ich habe einfach

fileWriter.flush();
fileWriter.close();

an eine andere Stelle gepackt, wobei sie eigentlich immer noch im selben Moment ausgeführt wird.

 

[KonradN]

Wenn ich die getWriter()-Methode in Verwendung ziehen würde, würde sich IntelliJ um FileWriter und PrintStream streiten

Ja, System.our ist ein PrintStream - wenn man Code im Forum schreibt, dann passieren so Fehler.

Dann macht man halt
return new OutputStreamWriter(System.out);

=> sprich einfach einen Writer auf dem Stream erzeugen.

 

[Gelöschtes Mitglied 67123]

Ja, System.our ist ein PrintStream - wenn man Code im Forum schreibt, dann passieren so Fehler.

Dann macht man halt
return new OutputStreamWriter(System.out);

=> sprich einfach einen Writer auf dem Stream erzeugen.

wenn man Code im Forum schreibt, dann passieren so Fehler.

Alles gut 😀
Ich habe deinen Code in meinen einbinden können, aber der ist um viele viele Sekunden langsamer, wenn der 65.536 Kombinationen generieren soll.

 

[berndoa]

Das ist zwar für deinen Fall vermutlich viel zu overkill und auch für solch kleine Zahlen zu ineffizient.
Aber ich habe mir bei einer mathematischen Aufgabe, wo ich größenmässig an die Obergrenzen von int und long stieß (also sehr große Zahlen!)
mir meine eigenen Zahlen gebaut im Sinne eines Arrays bzw. einer ArrayList.
bspw. in einer eigenen Klasse
bspw. für eine 6stellige Zahl also ein

int[] number= new int[6];

erzeugt bei dem jedes Element für eine "Stelle/Ziffer" der Gesamtzahl steht.
Und diese Zahl anfangs auf das Kleinstmögliche initialisiert, in deinem Fall als "000000".

Dann in der Klasse noch eine Methode zum Erhöhen eingebaut, die folgendem Algorithmus folgt:

//gehe zur kleinsten stelle (ziffer ganz rechts, aka ziffer mit index=length-1)
//falls gleich maximalziffer, dann gehe eine ziffer nach links, (index=index-1)
//mache das bis entweder index<0 (dann ist die gesamtzahl bereits maximal)
//oder bis ziffer<maximalziffer gefunden.
//in letzterem fall setzt du diese aktuelle stelle um eins höher (also number[index]++)
//dann setzt du alle ziffern rechts von dieser gerade erhöhten stelle auf die minimalziffer
//fertig

//spiels einfahc mal bei dem übergang von der Zahl 008999 zu 009000 durch, da erkennst du das Prinzip

In Obigem Algorithmus bin ich vom zehnerbasissystem augegangen wo die ziffern bekanntlich von 0-9 gehen
und man ganz normal +1 rechnen kann zum "erhöhen".

wenn du sozusagen "custom" ziffern hast, macht es sinn die in einem array zu haben.
eine methode dazu die dir zu einer vorgegebenen Ziffer die "nächsthöhere" (also die mit nächsthöherem index) gibt.
eine methode (oder hardcoden) welches die minimalziffer bestimmt sowie die maximalziffer.

usw.



klingt sehr umständlich, ist es auch.

Aber so kann ich bspw. Zahlen mit 10^30 ziffern haben, wobei jede "ziffer" so ziemlich alles sein kann. kann was zwischen 0 und zzz sein.
oder was Anderes.

Frage ist nur ob der Computer durchhält wenn man solche Sachen macht.
Und garantiert lässt sich sowas performancemässig viel mehr optimieren, also bspw. mit char array arbeiten, usw.

Vermutlich viel zu umständlich gedacht, aber das wäre die noobmässigste Art das zu lösen.


In deinem Fall tuen es aber normale Hexadezimalzahlen, braucht es keine customklasse für ein eigens gebautes zahlenbasissystem.