java - 如何检查二维阵列棋盘游戏的邻居

Question

所以我必须创建一个二维棋盘游戏。我已经设法完成了董事会，并且能够设置“X”行和 col 协调显示。我需要做的最后一个是检查“X”的周围环境，无论给定的坐标是否落在这个附近区域。这应该涵盖isIsolated()方法。

我有两种情况：

1. 当“X”在棋盘中间某处时：

• 如果坐标落在（粗体）0区域，我的方法应该return false是，如果其他地方不在附近，那么return true
• 例如，设置我的点(3, 3)，检查点(2, 1) isIsolated()是否应该返回true，因为它不靠近或不在 的区域内X，对于点(2, 3)，它返回false，因为它落在该区域

0 0 0 0 0 0

0 0 0 0 0 0

0 0 X 0 0 0

0 0 0 0 0 0

0 0 0 0 0 0

2. 当'X'在角落里时：

• 同样的事情，如果给定的坐标落在（粗体）0区域，我的方法应该return false，否则return true
• 例如，我将我的点设置为(1, 1)and (3, 4)，所以如果我想检查 if point (2, 2) isIsolated()，我应该得到false，如果 fg point (1, 3)，它应该返回true

X 0 0 0

0 0 0 0

0 0 0 X

到目前为止，我的代码如下所示：

public class Board {
    public char[][] field;

    public Board(int rows, int columns) {
        field = new char[rows][columns];
        for(int row = 0; row < rows; row++){
            for (int col = 0; col < columns; col++){
                field[row][col] = '0';
            }
        }

    }

    public void set(int row, int column) {
        try{
            for (int r = 0; r < field[0].length ; r++){
                for(int c = 0; c < field[1].length ; c++){
                    if(r == row - 1 && c == column - 1 && field[r][c] != 'X'){
                        field[r][c] = 'X';
                    }
                }
            }
        }catch (IllegalArgumentException e){
            if(row > field[0].length || column > field[1].length){
                System.out.println("Board isn't big enough!");
            }
        }


        System.out.println(Arrays.deepToString(field));
    }

    public boolean isSet(int row, int column) {
        for(int r = 0; r < field[0].length; r++){
            for(int c = 0; c < field[1].length; c++){
                if(r == row - 1 && c == column - 1){
                    if(field[r][c] == 'X'){
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public boolean isIsolated(int row, int column) {
  
        return true;
    }

}

并对其进行测试：

    @Test
    public void boardKnowsIfSquareIsIsolated() {

        Board board = new Board(5, 6);

        assertThat(board.isIsolated(3, 3), is(true));

        board.set(3, 3);

        assertThat(board.isIsolated(2, 2), is(false));
        assertThat(board.isIsolated(2, 3), is(false));
        assertThat(board.isIsolated(2, 4), is(false));

        assertThat(board.isIsolated(3, 2), is(false));
        assertThat(board.isIsolated(3, 3), is(false));
        assertThat(board.isIsolated(3, 4), is(false));

        assertThat(board.isIsolated(4, 2), is(false));
        assertThat(board.isIsolated(4, 3), is(false));
        assertThat(board.isIsolated(4, 4), is(false));

        assertThat(board.isIsolated(4, 5), is(true));
    }

    @Test
    public void canHandleEdges() {

        Board board = new Board(3, 4);

        board.set(1, 1);
        board.set(3, 4);

        assertThat(board.isIsolated(1, 1), is(false));
        assertThat(board.isIsolated(1, 2), is(false));
        assertThat(board.isIsolated(3, 3), is(false));
        assertThat(board.isIsolated(3, 4), is(false));

        assertThat(board.isIsolated(1, 4), is(true));
    }

标签： javamultidimensional-array

Answer 1

如果您有一个从 0 开始的r,c坐标并且想要检查它是否是 an'X'或在 an 附近'X'，您真的想检查r,c坐标周围的 3×3 正方形，即左上角为 atr-1,c-1和右下角为 at的正方形r+1,c+1. 您可以为此使用循环。

private static boolean isNearX(int r, int c) {
    for (y = r - 1; y <= r + 1; y++)
        for (x = c - 1; x <= c + 1; x++)
            if (field[y][x] == 'X')
                return true;
    return false;
}

当然，那个 3×3 的方块可能会部分落在棋盘之外，所以我们需要检查循环的上限和下限。这比检查 3×3 正方形中每个单元格的坐标更有效。

private static boolean isNearX(int r, int c) {
    int minY = Math.max(r - 1, 0), maxY = Math.min(r + 1, field.length - 1);
    int minX = Math.max(c - 1, 0), maxX = Math.min(c + 1, field[0].length - 1);
    for (y = minY; y <= maxY; y++)
        for (x = minX; x <= maxX; x++)
            if (field[y][x] == 'X')
                return true;
    return false;
}

现在，如果你想用基于 1 的row,column坐标来调用它，那很容易调整。我们还可以翻转真/假值以使其与isIsolated视点匹配。

public static boolean isIsolated(int row, int column) {
    int minY = Math.max(row - 2, 0), maxY = Math.min(row, field.length - 1);
    int minX = Math.max(column - 2, 0), maxX = Math.min(column, field[0].length - 1);
    for (y = minY; y <= maxY; y++)
        for (x = minX; x <= maxX; x++)
            if (field[y][x] == 'X')
                return false;
    return true;
}