Rekursiv Kombinationen ausgeben klappt nur bei einer Wiederholung

[DichterDichter]

Hallo werte Community,

ich habe hier ein Problem, das ich lösen will und habe auch schon einen
Teil geschafft. Das Programm kriegt per Kommandozeile einen Parameter,
dieser ist die Anzahl, wie oft hintereinander gewürfelt wird. Der Würfel hat
6 Seiten, zwei Seiten jeweils die selbe Farbe. Nun will ich die Kombinationen
ausgeben, die entstehen können.

public class Kombinationen {

	public static void main(String[] args) {
		
		int n = Integer.valueOf(args[0]);
		printKombinationen(n);
	}
	
	static void printKombinationen(int anzahlWurf) {
	
		char[] farbe = {'B', 'G', 'R'}; 
		for (int i = 0; i < anzahlWurf+1; ++i) {
			Out.println(farbe[i]);
		}	
	}
}

Hiermit klappt es, jedoch nur für einen Wurf. Da wird ausgegeben:
B
G
R

Ich hänge bei dem rekursiven Teil, der noch eingebaut werden muss, sodass bei zwei Würfen
zum Beispiel das hier ausgegeben wird:
BB
BG
BR
GB
GG
GR
RB
RG
RR

Habt ihr vielleicht ein paar Tips für mich?

Liebe Grüße
DD

 

[Kaibear]

Das Problem liegt darin, dass du also das komplette Array ausgeben willst, wenn ich das recht verstehe, du aber nur einen Eintrag aus dem Array angezeigt bekommst.

Was ich aus deinem Code auch noch als Problem entnehme, ist, dass du bei mehr als drei Würfen wohl einen Error bekommst. Denn du ratterst ja nur dein fabe-Array ab:

Wurf 1 ist immer B
Wurf 2 ist immer G
Wurf 3 ist immer R


Die Sache mit der Ausgabe mehrerer Elemente aus dem Array liegt aber an der Anweisung innerhalb der for-Schleife.

Da müsstest du dann eben nicht nur das Element i ausgeben.

Sähe dann in etwa so aus:

    public class Kombinationen {
     
        public static void main(String[] args) {
           
            int n = Integer.valueOf(args[0]);
            printKombinationen(n);
        }
       
        static void printKombinationen(int anzahlWurf) {
       
            char[] farbe = {'B', 'G', 'R'};
            for (int i = 0; i < anzahlWurf+1; ++i) {
                Out.println(farbe.toString()); // DAS IST DIE ÄNDERUNG
            }  
        }
    }

Aber das wäre dann vom Wurf unabhängig. Das Konzept ist dafür Murks.

Du musst über nen Zufalls-Generator die Farben zufällig zuweisen. Dazu müsstest du das Array farbe leer starten und dann auch mit integer-Werten und über nen Zufallsgenerator (in Java schon mit der Math-Klasse mitgebracht) der nur zwischen 1 und 3 wählt, füttern.

Sodass eben abhängig vom Würfel Arrays folgender Form entstehen:

farbe = [1,2,1,3,3,2] bei 6 Würfen
farbe = [2,1] bei zwei Würfen
farbe = [2,3] bei zwei Würfen etc.

Das Array wird also nach Eingabe der Würfen erstellt. Das sähe dann wie folgt aus:

int[] farbe = new int[anzahlWuerfe];
for(int i = 0; i <= anzahlWuerfe; i++){
    farbe[i] = (Math.random() * 3) + 1)
}
System.out.println(farbe.toString()) //toString() selbst schreiben.

Vom Konzept her stehen dann die Zahlen für Farben, was du aber mit einer selbstgeschriebenen toString()-Funktion umwandeln kannst, sodass eben anstatt 1 ein B, anstatt 2 ein G, anstatt 3 ein R ausgegeben wird.

Was noch zu bemängeln wäre, dass die Funktion nicht static ist und gegebenenfalls drüber nachgedacht werden sollte das Array als Rückgabe-Wert zu haben und den Print separat in einer Main-Klasse auszuführen. Aber das ist noch Wunschkonzert.

 

[rme]

Zufallsgenerator? Array mit Zahlen? Hm, ich verstehe die Aufgabe wohl völlig anders. Das Problem soll ja durch Rekursion gelöst werden, daher ist der Anfang im 1. Post genau richtig. Es fehlt allerdings noch der rekursive Aufruf und eine Anpassung der Schleife:

Bei einem Wurf muss das ganze Array genau einmal ausgegeben werden, denn alle Farben sind möglich. Bei 2 Würfen muss die Methode aber auch das ganze Array genau einmal ausgeben, den Rest macht nämlich die Rekursion. Deshalb muss die Schleife das Array einfach immer exakt einmal ausgegeben, unabhängig von der Anzahl der Würfe.

Wie kommt nun der nächste Wurf zustande, wenn das Array immer nur eimal ausgegeben wird? Im Format der gewünschten Ausgabe siehst du ja, dass zuerst "B" ausgegeben wird und danach einmal das gesamte Array. Also muss die Rekursion beim Ausführen der ersten Iteration ('B') in die Rekursion gehen, damit hinter dem B alle anderen Farben einmal ausgegeben werden. Dabei entsteht nun das Problem, dass die rekursiven Aufrufe irgendwie wissen müssen, dass das B ausgegeben werden soll, denn wenn die aufrufende Funktion es vor der Schleife ausgibt, wird es nur beim 1. rekursiven Aufruf ausgegeben. Eine mögliche Lösung wäre es, in der Schleife keine Ausgabe zu machen, sondern den Ausgabe-String dynamisch zusammenzusetzen und den rekursiven Aufrufen mitzugeben, d.h. du erweiterst die Methode um einen Parameter vom Typ String und einen Rückgabewert vom Typ String. Sie wird dann mit "" als Ausgabe aufgerufen, fügt dort in der 1. Iteration 'B' hinzu und die Rekursionen hängen dann jeweils ihre Ausgaben an den String und rufen wieder rekursiv auf, in der 1. Iteration der 2. Stufe also "BB".

Wie erkennst du nun, wann die Rekursion zu Ende ist? Dazu könntest du den Parameter anzahlWurf in jeder Stufe dekrementieren. Also wenn du initial mit 3 aufrufst, bekommt die nächste Stufe 2, die nächste 1 usw. Dann erkennst du nämlich, wann der letzte Würfel gefallen ist und kannst den dynamisch zusammengebauten String ausgeben, statt wieder in die Rekursion zu gehen.

 

[Kaibear]

Zufallsgenerator? Array mit Zahlen? Hm, ich verstehe die Aufgabe wohl völlig anders. Das Problem soll ja durch Rekursion gelöst werden, daher ist der Anfang im 1. Post genau richtig. Es fehlt allerdings noch der rekursive Aufruf und eine Anpassung der Schleife:

Bei einem Wurf muss das ganze Array genau einmal ausgegeben werden, denn alle Farben sind möglich. Bei 2 Würfen muss die Methode aber auch das ganze Array genau einmal ausgeben, den Rest macht nämlich die Rekursion. Deshalb muss die Schleife das Array einfach immer exakt einmal ausgegeben, unabhängig von der Anzahl der Würfe.

Wie kommt nun der nächste Wurf zustande, wenn das Array immer nur eimal ausgegeben wird? Im Format der gewünschten Ausgabe siehst du ja, dass zuerst "B" ausgegeben wird und danach einmal das gesamte Array. Also muss die Rekursion beim Ausführen der ersten Iteration ('B') in die Rekursion gehen, damit hinter dem B alle anderen Farben einmal ausgegeben werden. Dabei entsteht nun das Problem, dass die rekursiven Aufrufe irgendwie wissen müssen, dass das B ausgegeben werden soll, denn wenn die aufrufende Funktion es vor der Schleife ausgibt, wird es nur beim 1. rekursiven Aufruf ausgegeben. Eine mögliche Lösung wäre es, in der Schleife keine Ausgabe zu machen, sondern den Ausgabe-String dynamisch zusammenzusetzen und den rekursiven Aufrufen mitzugeben, d.h. du erweiterst die Methode um einen Parameter vom Typ String und einen Rückgabewert vom Typ String. Sie wird dann mit "" als Ausgabe aufgerufen, fügt dort in der 1. Iteration 'B' hinzu und die Rekursionen hängen dann jeweils ihre Ausgaben an den String und rufen wieder rekursiv auf, in der 1. Iteration der 2. Stufe also "BB".

Wie erkennst du nun, wann die Rekursion zu Ende ist? Dazu könntest du den Parameter anzahlWurf in jeder Stufe dekrementieren. Also wenn du initial mit 3 aufrufst, bekommt die nächste Stufe 2, die nächste 1 usw. Dann erkennst du nämlich, wann der letzte Würfel gefallen ist und kannst den dynamisch zusammengebauten String ausgeben, statt wieder in die Rekursion zu gehen.

So kann man die Aufgabe natürlich auch verstehen. Es ist jetzt die Frage, ob er alle Kombinationen erhalten will oder eine spezifische...

 

[rme]

Der gewünschten Ausgabe (9 Ausgaben bei 2 Würfen mit 3 Elementen) habe ich entnommen, dass er alle will 🙂

Nachtrag: Ich hab's gerade mal selbst ausprobiert, das mit dem Rückgabewert ist nicht einmal erforderlich. Einfach die Ausgabe durchschleifen und bei anzahlWurf == 0 ausgeben, ansonsten in die Rekursion gehen. Ich musste eigentlich nur 2 Zeilen anpassen und den Parameter hinzufügen, du bist also schon fast fertig. Ist eher eine Denkaufgabe 🙂