Zweidimensionales Array mit zufälligen Zahlen befüllen in zweierpaaren?
Wie kann ich in Java ein Zweidimensionales Array für ein Memory-Game mit zufällig angeordnet mit Zahlen befüllen, sodass jede Zahl zweimal vorkommt und dadurch "Paare" entsthen? Soll heißen: Ich habe beispielswise ein 4x4 großes Array, das mit den Zahlen 1-8 befüllt ist und jede Zahl kommt zweimal vor.
4 Antworten
Hallo.
Dafür gibt es mehrere Möglichkeiten. Beispielsweise könntest du einen weiteren Container anlegen, wo du die Anzahl der "Memory Karten" hinterlegst. Bei einem 4*4 Array erzeugst du also eine Liste, wo dann die Zahlen 1-8 jeweils 2 mal vorkommen.
Also zum Beispiel so:
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class ListToArrayConverter {
public static void main(String[] args) {
int anzahl = 16; //hier stehen die Anzahl der Memory Karten drin
if (anzahl > 0 && anzahl%2 == 0) { //Sicherstellen dass das Memory so funktioniert
List<Integer> list = createList(anzahl); //Hier wird die Liste befüllt
int[][] array = createArrayFromList(list); // Das 4x4 Array erstellen und mit den Werten aus der Liste füllen
// Geben wir noch das Array aus
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
} else { //Fehlermeldung ausgeben
System.out.println("Die Anzahl muss gerade sein, ist derzeit " + anzahl + "!");
}
}
public static List<Integer> createList(int anzahl) {
List<Integer> list = new ArrayList<Integer>();
for (int i=1; i<(anzahl/2)+1; i++) {
list.add(i);
list.add(i);
}
return list;
}
public static int[][] createArrayFromList(List<Integer> list) {
int[][] array = new int[4][4];
Random random = new Random();
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (!list.isEmpty()) {
int randomIndex = random.nextInt(list.size());
int value = list.remove(randomIndex);
array[i][j] = value;
}
}
}
return array;
}
}
Alternativ könntest du auch ein Array nach gleichem Muster anlegen und dann mittels Shuffle-Methode die Einträge vertauschen.
Allerdings bin ich unsicher, ob ein Array hier die beste Wahl ist. Denn dann hast du ja den Trouble mit gezogenen Einträgen...
Trotzdem viel Erfolg. 👍
Die Größe deines Arrays sei n x n
Du erzeugst in einer Schleife n x n / 2 Zufallszahlen und speicherst diese jeweils doppelt in einer Liste. Dann mischst du die Liste. Anschließend verteilst du die Zahlen in dein 2-dimensionales Array:
List<Integer> myList = new ArrayList<>();
Random rnd = new Random();
for (int i=0;i<n*n/2;i++) {
int num = rnd.nextInt(1000);
myList.add(num);
myList.add(num);
}
Collections.shuffle(myList);
for (int i=0; i < n*n; i++) {
myArray[i/n][i%n] = myList.get(i);
}
Ohne Gewähr und Pistole!
Doch, die zufälligen Zahlen werden ja jeweils zweimal in die Liste eingefügt
Ahh, i see. So kann man die Aufgabe natürlich auch verstehen, ja.. 😂
Ich denke mit „Zahlen von 1-8“ meinte er aber nicht irgendwelche Zufallszahlen zwischen 1 und 8 sondern wirklich einfach alle von 1 bis 8. Geht sich bei 16 Felder ja genau auf.
Bei dir hingegen könnte es die 5 z.B. auch viermal geben (zwei Zweierpaare) und die 3 dafür garnicht, usw.
mit „Zahlen von 1-8“ meinte er aber nicht irgendwelche Zufallszahlen zwischen 1 und 8 sondern wirklich einfach alle von 1 bis 8
Stimmt. Das hatte ich übersehen.
Aus
for (int i=0;i<n*n/2;i++) {
int num = rnd.nextInt(1000);
myList.add(num);
myList.add(num);
}
wird dann einfach
for (int i=1;i<=n*n/2;i++) {
myList.add(i);
myList.add(i);
}
Schritt 1:
Generiere eine Liste, die zwei mal alle Zahlen von 1 - 8 enthält.
Schritt 2:
Shuffle diese Liste
Schritt 3:
Füge die Zahlen dieser Liste einfach nacheinander in dein 2D Array ein
—
Der Code dafür wurde bereits gepostet, siehe Antwort von daCypher.
Den Shuffle-Schritt könnte man auch weglassen, indem man die Zahlen in zufälliger Reihenfolge aus der Liste nimmt. Siehe die createArrayFromList-Funktion in GuteAntwort2021‘s Antwort.
Ich würde einfach erstmal eine eindimensionale Liste anlegen, wo jede Karte zweimal drin ist, die dann durchmischen und das Ergebnis auf ein zweidimensionales Array verteilen
Etwa so:
import java.util.*;
import java.util.stream.IntStream;
public class MemoryGame {
// Die main-Methode ist nur zum testen drin. Die kannst du wieder rausnehmen
public static void main(String[] args) {
var cards = shuffledCards(4, 4);
for (var col: cards) {
System.out.println(Arrays.toString(col));
}
}
private static int[][] shuffledCards(int width, int height) {
// von jeder Karte ein Paar erstellen
var cards = new ArrayList<>(
IntStream
.range(0, width * height)
.mapToObj(num -> num/2)
.toList()
);
// Karten mischen
Collections.shuffle(cards);
// und in ein zweidimensionales Array einsortieren
var cardIterator = cards.iterator();
var result = new int[width][height];
for (int col = 0; col < width; col++) {
for (int row = 0; row < height; row++) {
result[row][col] = cardIterator.next();
}
}
return result;
}
}
Die Zahlen bilden dann aber keine Zweierpaare …