Java wordsearch 字符数组

Question

我已经为这个词搜索项目苦苦挣扎了几天，只是想让水平搜索工作。它意味着在所有 8 个可能的方向(水平、垂直、对角线)上工作。这是我当前的代码。

现在我只担心水平方向，因为我怀疑如果我正确地进行了比较，那么剩下的事情会更简单。

我打算编写代码来查找 boards 数组中包含的单词，并将这些字符输出到另一个与 board 数组大小相同的数组(因此，输出数组是 board 数组的解)。

到目前为止，我的代码所做的就是遍历整个棋盘，然后检查它是否与单词表的第一个字符匹配，如果匹配则将该字符分配到输出数组中，最后打印出来输出到控制台供用户查看。

我的问题是，我如何转发我的搜索以迭代单词列表？我的方法错了吗？例如，如果棋盘字符与单词列表中的字符匹配，则继续沿指定方向(在我的例子中，我担心的是水平方向)找到单词。

此外，方法“filter”旨在处理异常超出范围，以防搜索超出范围。

欢迎任何想法或方法。

Answer 1

下面是一个在网格中搜索不同方向单词的示例。我已经实现了其中的三个，剩下三个留给你完成。根据我个人的喜好，我会为 wordList 使用字符串数组而不是锯齿状数组，但我选择了 OP 的实现选择。我使用 4 x 4 网格和 3 个单词的列表制作了一个简单版本。请注意，我在输出板上调用了 fillWithSpaces()。这对于格式化至关重要。

我有一个名为“board.txt”的文本文件

dcat
aoiq
eigk
snur

和一个文本文件“words.txt”

dog
cat
runs

这是程序的输出:

DCAT
-O--
--G-
SNUR

我的策略是在黑板上搜索单词的第一个字母。找到它后，我更新静态字段 foundRow 和 foundColumn。当我使用不同的词时，我更新静态字段 currentWord。当我找到匹配的字母时，我有六种不同的方法，checkForwards() checkBackwards() 等等。 (还有其他方法可以做到这一点，但我试图让这个例子尽可能清楚。

这是向后检查的方法。因为我已经知道第一个字母匹配，所以我从第二个(索引 1)开始。对于每个新字符，我会在比较值之前检查它是否在板上。 (也有更好的方法来做到这一点)。如果有任何失败，我会回来。如果所有字符都匹配，我会一次复制一个字符。

static void checkBackwards()
{
    for(int i = 1; i < wordList[currentWord].length; i++)
    {
        if(foundColumn - i < 0) return;
        if(wordList[currentWord][i] != board[foundRow][foundColumn - i]) return;
    }
    //if we got to here, update the output
    for(int i = 0; i < wordList[currentWord].length; i++)
    {
        output[foundRow][foundColumn - i] = wordList[currentWord][i];
    }
    return;
}

这里是源代码:

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Wordsearch 
{
    static Scanner input;
    static char[][] wordList;
    static char[][] board;
    static char[][] output;

    static int foundRow;
    static int foundColumn;
    static int currentWord;

    public static void main(String[] args) throws FileNotFoundException
    {
        File wordInput = new File("words.txt");
        File boardInput = new File("board.txt");
        if(!wordInput.exists() || !boardInput.exists())
        {
            System.out.println("Files do not exist.");
            System.exit(1);
        }

        wordList = new char[3][];   //word list matrix 
        board = new char[4][4]; //board or grid matrix
        output= new char[4][4]; //solved puzzle 

        fillWithSpaces(output);

        input = new Scanner(wordInput);
        for(int i = 0; i < wordList.length; i++)
        {
            wordList[i] = input.nextLine().toUpperCase().toCharArray();
        }

        input = new Scanner(boardInput);
        for(int i = 0; i < board[0].length; i++)
        {
            board[i] = input.nextLine().toUpperCase().toCharArray();
        }

        for(int i = 0; i < wordList.length; i++)
        {
            currentWord = i;
            if(findFirstLetter())
            {
                checkEachDirection();
            }
        }

        print(output);
    }

    static boolean findFirstLetter()
    {
        for(int r = 0; r < board.length; r++)
        {
            for(int c = 0; c < board.length; c++)
            {
                if(wordList[currentWord][0] == board[r][c])
                {
                    foundRow = r;
                    foundColumn = c;
                    return true;
                }
            }
        }
        return false;
    }

    static void checkEachDirection()
    {
        checkForwards();
        checkBackwards();
        //checkUp();
        //checkDown();
        checkDiagonalDown();
        //checkDiagonalUp();
    }

    static void checkForwards()
    {
        for(int i = 1; i < wordList[currentWord].length; i++)
        {
            if(foundColumn + i > board.length - 1) return;
            if(wordList[currentWord][i] != board[foundRow][foundColumn + i]) return;
        }
        //if we got to here, update the output
        for(int i = 0; i < wordList[currentWord].length; i++)
        {
            output[foundRow][foundColumn + i] = wordList[currentWord][i];
        }
        return;
    }

    static void checkBackwards()
    {
        for(int i = 1; i < wordList[currentWord].length; i++)
        {
            if(foundColumn - i < 0) return;
            if(wordList[currentWord][i] != board[foundRow][foundColumn - i]) return;
        }
        //if we got to here, update the output
        for(int i = 0; i < wordList[currentWord].length; i++)
        {
            output[foundRow][foundColumn - i] = wordList[currentWord][i];
        }
        return;
    }

    static void checkDiagonalDown()
    {
        for(int i = 1; i < wordList[currentWord].length; i++)
        {
            if(foundColumn + i > board.length - 1) return;
            if(foundRow + i > board.length - 1) return;
            if(wordList[currentWord][i] != board[foundRow + i][foundColumn + i]) return;
        }
        //if we got to here, update the output
        for(int i = 0; i < wordList[currentWord].length; i++)
        {
            output[foundRow + i][foundColumn + i] = wordList[currentWord][i];
        }
        return;
    }

    static void print(char[][] board)
    {
        for(int i = 0; i < board.length; i++)
        {
            for(int j = 0; j < board.length; j++)
            {
                System.out.print(board[i][j]);
            }
            System.out.println();
        }
        System.out.println();
    }

    static void fillWithSpaces(char[][] board)
    {
        for(int i = 0; i < board.length; i++)
        {
            for(int j = 0; j < board.length; j++)
            {
                board[i][j] = '-';
            }
        }
    }
}