Question

我正试图遍历一个二维数组。我目前在char数组中设置了填字游戏，我需要能够检查一个字母的周围字母，看看我正在寻找的单词是否与第一个字母相关联。我已经设置了布尔方法来完成我需要的工作，但我想知道是否有办法检查我的当前计数器是否超出了我的数组范围。我的数组看起来像这样：

    W V E R T I C A L L 

    R O O A F F L S A B 

    A C R I L I A T O A 

    N D O D K O N W D C 

    D R K E S O O D D K 

    O E E P Z E G L I W 

    M S I I H O A E R A 

    A L R K R R I R E R 

    K O D I D E D R C D 

    H E L W S L E U T H

我目前的代码是：

    public static boolean check(int row, int col, String word, char[][] puzzle) {       
    if(checkRight(row, col, word, puzzle)) return true;
    if(checkLeft(row, col, word, puzzle)) return true;
    if(checkUp(row, col, word, puzzle)) return true;
    if(checkDown(row, col, word, puzzle)) return true;
    if(checkNW(row, col, word, puzzle)) return true;
    if(checkNE(row, col, word, puzzle)) return true;
    if(checkSW(row, col, word, puzzle)) return true;
    if(checkSE(row, col, word, puzzle)) return true;
    return false;
}

private static boolean checkRight(int row, int col, String word, char[][] puzzle) {
    //Checking right direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row][col + letter] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}


private static boolean checkLeft(int row, int col, String word, char[][] puzzle) {
    //Checking left direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row + letter][col] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}


private static boolean checkUp(int row, int col, String word, char[][] puzzle) {
    //Checking up direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row - letter][col] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}


private static boolean checkDown(int row, int col, String word, char[][] puzzle) {
    //Checking down direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row][col - letter] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}


private static boolean checkSE(int row, int col, String word, char[][] puzzle) {
    //Checking diagonals direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row + letter][col + letter] != word.charAt(letter) && <row<) {
            return false;
        }
    }
    return true;
}


private static boolean checkSW(int row, int col, String word, char[][] puzzle) {
    //Checking diagonals direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row + letter][col - letter] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}

private static boolean checkNW(int row, int col, String word, char[][] puzzle) {
    //Checking diagonals direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row - letter][col - letter] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}

private static boolean checkNE(int row, int col, String word, char[][] puzzle) {
    //Checking diagonals direction
    for(int letter = 1; letter < word.length(); letter++) {
        if(puzzle[row - letter][col + letter] != word.charAt(letter)) {
            return false;
        }
    }
    return true;
}
}

非常感谢任何帮助！

Answer 1

您需要一个适用于各个方向的通用功能。也就是说，通过添加范围为offsetx的{{1}}和offsety，您可以在当前位置计算您的邻居的位置。看看这个代码几乎可以满足您的需求：

[-1,1]

这就是我们呼吁各方向的方式;

//This is your generic-direction function
public static boolean check(int row, int col, String word, char[][] puzzle, int offsetx, int offsety)

    //start with the current position
    int x = row;
    int y = col;

    for (int i = 0; i < word.lenth(); i++){
        //Is not equal
        if (puzzle[x][y] != word.charAt(i)) return false;

        //Calculate the next position
        x += offsetx;
        y += offsety;

        //check the boundaries, if we go out then we didn't find the word;
        if (x < 0 || x >= puzzle.length || y < 0 || y >= puzzle[x].length) return false;
    }

    return true;
}

但更简单的方法是在数组中定义偏移量，例如

//check right
if(check(row, col, word, puzzle, 1, 0)) return true;

//check left
if(check(row, col, word, puzzle, -1, 0)) return true;

//check top
if(check(row, col, word, puzzle, 0, -1)) return true;

...

Answer 2

这可以通过限制对检查功能的调用来解决。

例如：如果您开始的字母不在最左侧，您可以检查左侧的字，左上角和左上方，以及对角线上方和右侧......因为除此之外没有任何其他内容。这同样适用于顶部，底部和右侧。

此外，如果您的拼图在char [] []拼图中，拼图[0] .length和puzzle.length将获得拼图的尺寸，用于检查循环等作为上限或起点。 / p>

如何检查计数器是否超出范围

2 个答案: