LinkedList aus Arrays ( Mastermind )

[kenyo]

Hi , ich versuche gerade Mastermind zu programmieren. Der Lösungsraum für alle möglichen Lösungen soll in einer LinkedList gespeichert werden. Also hab ich eine LinkedList aus int[] erstellt. und befülle Ihn mit sämtlichen Lösungen.
//Man hat 6 Farben und 4 Positionen.
Bzw. eher versuche ich Ihn zu befüllen. Allerdings hänge ich jetzt schon eine ganze weile im Debugger und verstehe nicht wieso immer wenn ich etwas in das array loesung schreibe, nicht nur mein array loesung befüllt wird sondern alle nodes der linkedlist loesungen auch? Das Endprodukt ist nämlich statt des Lösungsraumes von 0000,0001,0002…5555 steht überall 5555 drin. Wäre nett wenn Ihr mir helfen könntet.

public class Loesungsraum {

        int[] loesung = new int[4];
    
	LinkedList<int[]> loesungen = new LinkedList<>();

	public Loesungsraum(int farben) {
            
            for(int i = 0; i<6; i++){
                loesung[0] = i;
                for(int j = 0; j<6; j++){
                    loesung[1] = j; 
                    for(int k = 0; k<6; k++){
                        loesung[2] = k;
                        for(int l = 0; l<6; l++){
                            loesung[3] = l;
                            loesungen.add(loesung);
                          //System.out.println(loesung[0]+""+loesung[1]+""+loesung[2]+""+loesung[3]);                            
                        }        
                    }
                }
            }
    	}

	public void printL(){
        
            for(int[] temp : loesungen)
            System.out.println(temp[0]+""+temp[1]+""+temp[2]+""+temp[3]);
        }```

[anon19643277]

Du addest immer das gleiche (identische) Array, welches sich im weiteren Verlauf weiter verändert. Ein
loesungen.add(loesung.clone());sollte Abhilfe schaffen.

[kenyo]

Erstmal danke für die schnelle Antwort. Heisst das, dass die Methode add() nur eine neue referenz auf mein array hinzufügt?

[SlaterB]

genau

[CyborgBeta]

So könntest du das auch machen:

        List<int[]> listia = new ArrayList<int[]>();
        for (int i = 0; i < 6 * 6 * 6 * 6; i++) {
            listia.add(new int[4]);
        }
        for (int i = 0; i < 6 * 6 * 6 * 6 - 1; i++) {
            int[] ia1 = listia.get(i);
            int[] ia2 = listia.get(i + 1);
            for (int j = 0; j < 4; j++) {
                ia2[j] = ia1[j];
            }
            for (int j = 3; j >= 0; j--) {
                if (ia2[j] == 5) {
                    ia2[j] = 0;
                } else {
                    ia2[j]++;
                    break;
                }
            }
        }

        for (int i = 0; i < 3; i++) {
            System.out.println("listia.get(i) = " + Arrays.toString(listia.get(i)));
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(Arrays.toString(listia.get((int) (Math.random() * (6 * 6 * 6 * 6)))));
        }
    }```

ODER: int[][]-Array oder LinkedList oder Deque/ArrayDeque.

In Zeile 9 sagt er mir Manual array copy, ich soll doch lieber `System.arraycopy(ia1, 0, ia2, 0, 4);` verwenden. Generell weiß ich nicht, ob `loesungen.add(loesung.clone());` [also .clone(] wie gewünscht funktioniert, aber .arraycopy( nicht besser/schneller ist.

Für 4 und 3 könnte man auch mit einer Variable length/len/laenge/usw. arbeiten.

Oder man nimmt eine eigene (, rekursive) Methode dafür.

[Timothy_Truckle]

wäre das[SPOILER]```public class MasterMind {
private static class EntryFactory {
int[] current;
int countColors;

    public EntryFactory(int maxColors, int countPositions) {
        super();
        this.current = new int[countPositions];
        this.countColors = maxColors;
        for (int i = 0; i < current.length; i++) {
            current** = 0;
        }
    }

    public int[] getNext() {
        buildNewCombi();
        return Arrays.copyOf(current, current.length);
    }

    private void buildNewCombi() {
        for (int i = 0; i < current.length; i++) {
            if (++current** >= countColors) {
                current** = 0;
            } else {
               return;
            }
        }
    }

    public boolean hasNext() {
        return countColors < current[current.length - 1];
    }
}

public static void main(String[] args) {
    EntryFactory entryFactory = new EntryFactory(6, 4);
    List<int[]> allCombinations = new ArrayList<int[]>();
    while (entryFactory.hasNext()) {
        allCombinations.add(entryFactory.getNext());
    }
}

}```[/SPOILER]
bye
TT

[CyborgBeta]

Schnell zur Erklärung der Vorgehensweise: Wenn ein aktuelles Element XYZ vorhanden ist, dann kann daraus das nächste Element einfach generiert werden, indem nur mindestens eine Ziffer geändert wird. Mein Vorschlag: Z wird erhöht, falls Z danach außerhalb des Bereichs ist, wird Z wieder zu 0 und Y wird erhöht usw. TTs Vorschlag: X wird erhöht, falls X…, wird X wieder… und Y wird… usw.

Das ergibt einmal: … 123, 131 usw. Und einmal: … 321, 131 usw.

Arrays.copyOf( ist wahrscheinlich besser und schneller sowohl als loesung.clone( wie auch System.arraycopy( .

“private static class EntryFactory {” == eigene Klasse, kürzere/elegantere Methoden.

Auch mal Methoden wie java.util.Collections.shuffle( ansehen.

Jetzt schließt sich der Kreis: Ich kenne das “Spiel” Mastermind nicht, wenn du willst, kannst du es kurz erklären. Möglicherweise ist ein “Array” / eine Liste mit allen “Spielsituationen” gar nicht benötigt.

Bitte gebt mir weitere Informationen…

[Marco13]

Für eine “KI” (wenn man es so nennen will) gab’s schonmal den Thread http://forum.byte-welt.net/threads/3724-Mastermind-NPC?p=16669&viewfull=1#post16669 , aber … darum ging es hier ja erstmal nicht…

[Timothy_Truckle]

[quote=CyborgBeta]Ich kenne das „Spiel“ Mastermind nicht, wenn du willst, kannst du es kurz erklären[/quote]http://de.wikipedia.org/wiki/Mastermind_%28Spiel%29

@CyborgBeta;96720

Möglicherweise ist ein „Array“ / eine Liste mit allen „Spielsituationen“ gar nicht benötigt.

ist sie nicht.

bye
TT

[CyborgBeta]

Hab 's mir durchgelesen, ihr anscheinend auch alle. 6 hoch 4 = 1296 Möglichkeiten, mit einer Taktik/Strategie sind es im worst case aber nur 6 Möglichkeiten. Ne, danke, dann spiele ich doch lieber Schach, denn da fängt mein Gegenüber nicht an, unfreundlich zu werden.

[Bleiglanz]

klarer wäre der Code so:

	public Loesungsraum() {
		for (int i = 0; i < 6; i++) {
			for (int j = 0; j < 6; j++) {
				for (int k = 0; k < 6; k++) {
					for (int l = 0; l < 6; l++) {
						loesungen.add(new int[]{i,j,k,l});
					}
				}
			}
		}
	}

[Timothy_Truckle]

[quote=Bleiglanz]klarer wäre der Code so:[/quote]Sicher, aber vielleicht wird es ja mit 6 Farben auf 4 Stellen irgendwann langweilig…

bye
TT

[anon19643277]

[QUOTE=Timothy_Truckle;96800]Sicher, aber vielleicht wird es ja mit 6 Farben auf 4 Stellen irgendwann langweilig…[/QUOTE]Deswegen gerät MasterMind wohl auch zunehmend in Vergessenheit.

[schlingel]

@Spacerat

Deswegen gerät MasterMind wohl auch zunehmend in Vergessenheit.

Ich kenn’s auch nur aus einer Programmierübung. Wir durften das ganze als PL/1 Code kennen lernen.

[SlaterB]

dabei schon immer als Spielgerät die Form eines Smartphones, was heute ja so modern und hip sein soll, nachdem was man so hört
eignet sich perfekt als App, gibts ja auch,

soviel aus der Offtopic-Welt