检查数组元素java的周围单元格

Question

I need to make a simple(standart) minesweeper for my project. I want to check the surrounding elements of a random(or specific) element of a 2d array.

lets say I have an array like that

boolean board[5][5]

I want to check the surrounding elements of

board[0][0]

I wrote that:

    public int numberChecker(int h, int w) {
    int checker = 0;        
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            int he = h - 1 + i;
            int wi = w - 1 + i;    <---- this i should be j that was the issue
            if (board.getHeight() > he && he >= 0 
                               && wi >= 0 && board.getWidth() > wi) {
            if (boomChecker(he, wi)) {
                if (w != (wi) && h != (he)) {
                    checker++;
                }
                }
            }
        }
    }                                   

    return checker;
}

the problem is I think it only checks " \\ " way (do not know how to put it in words)

ex:

(output # means uncovered numbers mean surrounding mines)

uncover 4-2

######
######
0#####
#0####
##0###     <-- unlocking this one
###0##

or

uncover 0-0

0#####
#0####
##0###
######     <-- there is a mine at check spot
######
######

the code itself is not important (I know I made it a bit complicated to explain myself)

all I need is a working surrounding checking for loop (or anything)

thanks in advance

Problem solved simple stupid mistake int he = h - 1 + i; int wi = w - 1 + i; <--- i should be j thanks

Answer 1

I think your mistake is in this 2 lines:

int he = h - 1 + i;
int wi = w - 1 + i;

you add to the height AND to the width the value of i. So you just check every of the 3 diagonal fields 3 times. I think it should be

int he = h - 1 + i;
int wi = w - 1 + j;

so you really iterate through all 9 possible fields and not just through the diagonale.

Hope that helps!

Answer 2

I'm going to write my answer as though answering a homework question

now what you really ought to do is, for each cell in your array, there are 8 other cells to check. so something like:

count += board[i-1][j-1] ? 1 : 0;
count += board[i-1][j] ? 1 : 0;
count += board[i-1][j+1] ? 1 : 0;
count += board[i][j-1] ? 1 : 0;
etc.

be sure to include some mechanism to prevent you from accessing elements outside the bounds of the array.

also, if you were wondering what the ? and : mean, look up the Ternary Operator It's useful in all sorts of situations.

Answer 3

By the way, you might be better off explicitly checking each of the 8 possible surrounding cells. It's entirely possible that the JVM might automatically unroll your loop, but I don't see why you wouldn't just check them explicitly. It will be faster, and easier to understand.

boolean upleft = board[row-1][column-1];
boolean up = board[row-1][column];
boolean upright = board[row-1][column+1];
boolean left = board[row][column-1];
boolean right = board[row][column+1];
boolean downleft = board[row+1][column-1];
boolean dow  = board[row+1][column];
boolean downright = board[row+1][column+1];

You'll of course have to do bounds checking if your on the edge of the board, but it makes more sense as to what is going on.