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.

Answer 1

[GuteAntwort2021]

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. 👍

Woher ich das weiß: Studium / Ausbildung – Diplom Wirtschaftsinformatiker

Answer 2

[Schachpapa]

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!

Comments

[MrAmazing2]

Die Zahlen bilden dann aber keine Zweierpaare …

[daCypher]

@MrAmazing2

Doch, die zufälligen Zahlen werden ja jeweils zweimal in die Liste eingefügt

[MrAmazing2]

@daCypher

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.

[Schachpapa]

@MrAmazing2

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);
}

Answer 3

[MrAmazing2]

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.

Woher ich das weiß: Hobby – Programmieren ist mein Hobby & Beruf

Answer 4

[daCypher]

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;
    }
}