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

Question

So I have to create a 2-dimensional board game. I've managed to do the board and I'm able to set the 'X' row and col coordinated show. The last this what I need to do, is check the surroundings of an 'X' whether given coordinates land on this neighbourhood area or not. This should cover isIsolated() method.

I have two cases:

1. When 'X' is somewhere in the middle of the board:

• If coordinates land on (bold) 0 area, my method should return false , if somewhere else as not in the neighbourhood, then return true
• for example, setting my point on (3, 3) , checking if point (2, 1) isIsolated() and it should return true , because it isn't close to or in the area of X , for point (2, 3) , it returns false , because it lands on the area

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. And when 'X' is in the corners:

• The same thing here, if given coordinates land on (bold) 0 area, my method should return false , otherwise return true
• for example, I set my points on (1, 1) and (3, 4) , so if I want to check if point (2, 2) isIsolated() , I should get false , if fg point (1, 3) , it should return true

X 0 0 0

0 0 0 0

0 0 0 X

My code looks like this so far:

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

}

And tests for it:

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

Answer 1

If you have a 0-based r,c coordinate and want to check if it is an 'X' or is near an 'X' , you really want to check the 3-by-3 square around the r,c coordinate, ie the square with upper-left at r-1,c-1 and lower-right at r+1,c+1 . You can use loops for that.

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

Of course, that 3-by-3 square may fall partially outside the board, so we need to check the upper and lower limits of the loops. This more efficient than checking the coordinates for every cell in the 3-by-3 square.

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

Now, if you want to call it with the 1-based row,column coordinate instead, that's easy to adjust. We can also flip the true/false value to make it match the isIsolated point of view instead.

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