Как перетасовать колоду из двухмерного массива

Question

У меня проблема с перетасовкой двух колод. Я создал две колоды, используя двумерный массив. Имейте в виду, что это были требования. Мне также необходимо перемешать их, используя метод shuffle (), который принимает одномерный массив и возвращает одномерный массив.

После перетасовки обеих колод мне нужно выбрать первые две карты из первой колоды и первые две карты из второй колоды и проверить, совпадают ли они. А также количество тасовок, необходимых для получения результата.

Пример вывода:

Две карты для точного матча из колоды 1: Ace of Diamonds, 2 of Clubs

Две карты для точного матча из колоды 2: Ace of Diamonds, 2 of Clubs

Количество перемешанных раз: 387

Это вторая часть проекта, над которым мы работали, и ниже я попытался решить эту проблему.

Я пытался создавать колоды, используя приведенный ниже код, который работал

int[][] deck = new int[2][52];

for (int i = 0; i <= deck.length - 1; i++) {
    for (int j = 0; j < deck[i].length; j++) {
        deck[i][j] = j;
    }
}

И я написал метод shuffle, но, похоже, он не работает.

public static int[] shuffle(int[] deck) {
  for(int i=0; i<deck.length; i++) {  
  int index = (int)(Math.random()* deck.length); 
  int temp = deck[i];  
  deck[i] = deck[index];
  deck[index] = temp;
  }
return deck;    

} * * тысяча двадцать-один

Приведенный ниже код является исходным кодом из первой части этого проекта, где мы должны были напечатать четыре вида из одной колоды после перетасовки и подсчитать, сколько перетасовок потребовалось, чтобы получить четыре вида

class Main {
  public static void main(String[] args) {

  String[] suit = { "Spades", "Hearts", "Diamond", "Clubs" };

  String[] rank = { "Ace", "1", "2", "3", "4", 
                 "5", "6", "7", "8", "9",
                 "10", "Jack", "Queen", "King" };

  int rank1, rank2, rank3, rank4, suit1, suit2, suit3, suit4, count = 0; 

  int[] deck = new int[52];

  for (int i = 0; i < deck.length; i++) {
     deck[i] = i;
  }

  do {

    count++;
    for (int i = 0; i < deck.length; i++) {

       int index = (int) (Math.random() * deck.length);
       int temp = deck[i];
       deck[i] = deck[index];
       deck[index] = temp;
    }

    suit1 = deck[0] / 13;
    suit2 = deck[1] / 13;
    suit3 = deck[2] / 13;
    suit4 = deck[3] / 13;

    rank1 = deck[0] % 13;
    rank2 = deck[1] % 13;
    rank3 = deck[2] % 13;
    rank4 = deck[3] % 13;

  } while (rank1 != rank2 || rank2 != rank3 || rank3 != rank4);

    System.out.println(" Four-of-kind cards: " + suit[suit1] + " of "
        + rank[rank1] + ", " + suit[suit2] + " of " + rank[rank2]
        + ", " + suit[suit3] + " of " + rank[rank3] + ", "
        + suit[suit4] + " of " + rank[rank4]
        + "\n Number of shuffled times: " + count);

    }
}

Еще раз результат должен выглядеть следующим образом.

Пример вывода:

Две карты точного соответствия из колоды 1: Ace of Diamonds, 2 of Clubs Две карты точного матча из колоды 2: Ace of Diamonds, 2 of Clubs

Количество перемешанных раз: 387

Answer 1

Вы shuffle метод правильный.Нет необходимости делать другой метод перемешивания, который будет принимать двухмерный массив.Вам просто нужно вызвать метод shuffle в каждой колоде вашего 2D-массива.Для этого просто:

deck[0] = shuffle(deck[0]);
deck[1] = shuffle(deck[1]);

Я также обновил ваш код, чтобы его было легче модифицировать в случае возникновения дополнительных требований.См. Код ниже:

public class Main {
    public static String[] card; // The holder for all cards

    public static void main(String[] args) {
        card = generateCardSuits(); // generate the cards with their corresponding suits
        doPartOne();
        doPartTwo();
    }

    /**
     * Part One
     *
     */
    public static void doPartOne() {
        System.out.println("========== PART ONE ==========");
        int[] deck = generateAndShuffleInitialDeck();
        int ctr = 1;
        while (true) {
            if (deck[0] % 13 == deck[1] % 13 && deck[1] % 13 == deck[2] % 13 && deck[2] % 13 == deck[3] % 13) {
                break;
            }
            deck = shuffle(deck);
            ctr++;
        }
        System.out.println("Four-of-kind cards are: " + card[deck[0]] + " , " + card[deck[1]] + " , " + card[deck[2]]
                + " and " + card[deck[3]]);
        System.out.println("Number of shuffled times: " + ctr);
        System.out.println("==============================");
    }

    /**
     * Part Two
     *
     */
    public static void doPartTwo() {
        System.out.println("========== PART TWO ==========");
        int[][] deck = new int[2][52];
        deck[0] = generateAndShuffleInitialDeck();
        deck[1] = generateAndShuffleInitialDeck();

        int ctr = 1;
        while (deck[0][0] != deck[1][0] || deck[0][1] != deck[1][1]) {
            deck[0] = shuffle(deck[0]);
            deck[1] = shuffle(deck[1]);
            ctr++;
        }

        System.out.println("Two exact match cards from deck 1 are: " + card[deck[0][0]] + " and " + card[deck[0][1]]);
        System.out.println("Number of shuffled times: " + ctr);
        System.out.println("==============================");
    }

    /**
     * Generate an initial deck of cards and shuffle them
     *
     * @return The initial and shuffled deck of cards
     */
    public static int[] generateAndShuffleInitialDeck() {
        int[] deck = new int[52];

        for (int j = 0; j < deck.length; j++) {
            deck[j] = j;
        }
        return shuffle(deck);
    }

    /**
     * Generate the cards with their corresponding suits
     *
     * @return The deck that will serve as the mapper for the cards to their suits
     */
    public static String[] generateCardSuits() {
        String[] rank = { "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King" };
        String[] suit = { "Spades", "Hearts", "Diamond", "Clubs" };

        String[] cards = new String[52];

        for (int i = 0, j = 0, s = 0; i < cards.length; i++) {
            cards[i] = rank[j] + " of " + suit[s];
            j++;
            if (j == 13) { // Since each suit consist of 13 cards
                j = 0;
                s++;
            }
        }
        return cards;
    }

    /**
     * Shuffle the deck of cards
     *
     * @param deck
     *            the deck of cards to be shuffle
     *
     * @return The shuffled deck of cards
     */
    public static int[] shuffle(int[] deck) {
        for (int i = 0; i < deck.length; i++) {
            int index = (int) (Math.random() * deck.length);
            int temp = deck[i];
            deck[i] = deck[index];
            deck[index] = temp;
        }
        return deck;
    }
}