Question

我正在用Java设计一个扫雷游戏，而我在制作什么牌是地雷/不是地雷时遇到了麻烦。到目前为止，这是我的代码：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.Random;
import java.util.Scanner;

public class MineSweeper {
    private final boolean[][] mines;
    public char[][] field;

    public MineSweeper(int x, int y, int numMines) {
        field = new char[x][y];

        boolean[][] tmpMines = new boolean[x][y];

        Random rand = new Random();

        // Here is where I need to use rand to evenly disperse mines across 
        // the `tmpMines` array...

        for (int i = 0; i < x; i++)
            for (int j = 0; j < y; j++) {
                field[i][j] = 'X';
            }

        mines = tmpMines;
    }

    public void showFor(int x, int y) {
        int count = 0;

        for (int[] i : new int[][]{ /* Sides */ {x + 1, y}, {x - 1, y}, {x, y - 1}, {x, y + 1}, /* Corners */ {x + 1, y + 1}, {x - 1, y -1}, {x + 1, y - 1}, {x - 1, y + 1}}) {
            try {
                if (mines[i[0]][i[1]] == true)
                    count++;
            } catch (ArrayIndexOutOfBoundsException ex) {
                // Easiest way to handle overflow.
            }
        }

        field[x][y] = Integer.toString(count).charAt(0);
    }

    private static void printCharMatrix(char[][] matrix) {
        for (char[] a : matrix) {
            for (char c : a) {
                System.out.print(c + " ");
            }
            System.out.println();
        }
    }

    private static void printBoolMatrix(boolean[][] matrix) {
        for (boolean[] a : matrix) {
            for (boolean b : a) {
                if (b == true)
                    System.out.print("X ");
                else
                    System.out.print("O ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String input;

        Pattern patt = Pattern.compile("^\\s*(\\d+)\\s*,\\s*(\\d+)\\s*$"); // Matches any number of spaces, a digit, spaces, a comma, spaces, and a digit and extracts the 2 digits

        System.out.println("*** Welcome to MineSweeper(tm)!!! ***");
        System.out.println();
        System.out.print("Enter the number of columns: ");
        int x = scan.nextInt();
        System.out.print("Enter the number of rows: ");
        int y = scan.nextInt();
        System.out.print("Enter the number of mines: ");
        int mines = scan.nextInt();
        MineSweeper ms = new MineSweeper(x, y, mines);

        scan.nextLine();

        while (true) {
            System.out.println("Board:");
            printCharMatrix(ms.field);
            System.out.print("Type an array index (ex: 1,1). 'quit' to quit: ");
            input = scan.nextLine().toLowerCase();

            if (input.equalsIgnoreCase("quit"))
                System.exit(0);

            Matcher match = patt.matcher(input);

            if (match.find()) {
                x = Integer.parseInt(match.group(1));
                y = Integer.parseInt(match.group(2));
                if (ms.mines[x][y] == true) {
                    System.out.println("You failed!");
                    System.out.println("The board was: ");
                    System.out.println();
                    printBoolMatrix(ms.mines);
                    System.exit(0);
                } else {
                    ms.showFor(x, y);
                }
            } else {
                System.out.println("Invalid input: " + input);
            }
        }
    }
}

我需要做的是在mines之间均匀分散地雷（true如果它是地雷，false如果不是），根据提供的地雷数量和矩阵的大小（x * y）。我尝试了几种策略，但没有一种策略有效。谢谢！

Answer 1

您可以使用numMines true和x*y-numMines false填充tmpMines数组，并在其上使用随机数算法。

有几种随机播放算法可以实现这一点，例如，您可能希望使用this answer来重新排列二维数组。

// fill tmpMines array
for(int i = 0; i < x; i++) {
    for (int j = 0; j < y; j++) {
        if (numMines > 0) {
            numMines--;
            tmpMines[i][j] = true;
        } else {
            tmpMines[i][j] = false;
        }
    }
}
// shuffle tmpMines array
for(int i = 0; i < x; i++) {
    for (int j = 0; j < y; j++) {
        // int swapPos = rand.nextInt(x*y);  this swapPos selection is not correct, please use the code next line.
        int swapPos = x*y - rand.nextInt(x*y-i*y+j);
        int swapPosY = swapPos / x;
        int swapPosX = swapPos % x;

        boolean tmp = tmpMines[i][j];
        tmpMines[i][j] = tmpMines[swapPosX][swapPosY];
        tmpMines[swapPosX][swapPosY] = tmp;
    }
}

我在这里直接使用和修改numMines，因为在此代码之后不会使用它。如果您不想修改numMines，请使用临时变量。

P.S。你的专栏＆amp;你的代码中混合了一行（当我的输入显示7行时，我有7列）。使用二维阵列时请注意它们。

Answer 2

试试这个：

创建一个足以容纳所有值的列表
使用所需数量的真/假填充列表
随机播放列表
使用列表中的值填充最终数组

您不需要太多代码来完成所有这些：

public MineSweeper(int x, int y, int numMines) {
    mines = new boolean[y][x];
    List<Boolean> values = IntStream.range(0, x * y)
      .mapToObj(i -> i < numMines).collect(Collectors.CotoList());
    Collections.shuffle(values);
    IntStream.range(0, y).forEach(i -> IntStream.range(0, x)
      .forEach(j -> mines[i][j] = values.get(i * x + j)));
}

在列表中生成随机分散的真值和假值的麻烦

2 个答案: