java - 在 java 中使用二维数组进行单词搜索 - 越过第二个字母

Question

所以，我的任务是使用二维数组网格创建一个单词搜索程序。

到目前为止，我的代码可以在网格中找到所有 2 个字母的单词，但是长度超过 2 个字母并且代码会跳过它们。我目前在凌晨 2 点累得要死，所以它可能是我明显遗漏的东西，但如果不是，请帮帮我？

当前搜索代码：

   /**
     * Searches for a word in this LetterGrid using traditional WordSearch
     * rules.
     * 
     * @param word
     *            the word to look for
     */
    public boolean wordSearch(String word)
    {
            // Check each letter in grid
            for (int row = 0; row < this.noOfRows; row++)
            {
                    for (int col = 0; col < this.rowLength; col++)
                    {
                            if (grid[row][col] == word.charAt(0) && word.length() > 1)
                            {
                                    return gridCheck(row, col, word, 1);
                            }
                            else if (grid[row][col] == word.charAt(0))
                            {
                                    return true;
                            }
                    }

            }
            return false;
    }

    public boolean gridCheck(int row, int col, String word, int charToFind)
    {

            if (charToFind == word.length() - 1)
            {
                    return true;
            }
            else if (charToFind < word.length() - 1)
            {
                    // Where is the letter being checked? -contingency check-
                    // if letter being checked is not touching any edge [most likely]
                    if (row > 0 && row < this.noOfRows && col > 0
                                    && col < this.rowLength)
                    {
                            // FOR CODES SEE CHECKPLACES.TXT
                            // A
                            if (grid[row - 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // B
                            else if (grid[row - 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col, word, word.charAt(charToFind + 1));
                            }
                            // C
                            else if (grid[row - 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // D
                            else if (grid[row][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col - 1, word, word.charAt(charToFind + 1));
                            }
                            // E
                            else if (grid[row][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col + 1, word, word.charAt(charToFind + 1));
                            }
                            // F
                            else if (grid[row + 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // G
                            else if (grid[row + 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col, word, word.charAt(charToFind + 1));
                            }
                            // H
                            else if (grid[row + 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }

                    }
                    // Letter is touching top left corner
                    if (row == 0 && col == 0)
                    {
                            // E
                            if (grid[row][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col + 1, word, word.charAt(charToFind + 1));
                            }
                            // H
                            else if (grid[row + 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // G
                            else if (grid[row + 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col, word, word.charAt(charToFind + 1));
                            }
                    }
                    // Letter is touching top Right corner
                    if (row == 0 && col == this.rowLength)
                    {
                            // D
                            if (grid[row][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col - 1, word, word.charAt(charToFind + 1));
                            }
                            // F
                            else if (grid[row + 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // G
                            else if (grid[row + 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col, word, word.charAt(charToFind + 1));
                            }

                    }
                    // Letter is Touching bottom Left Corner
                    if (row == this.noOfRows && col == 0)
                    {
                            // B
                            if (grid[row - 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col, word, word.charAt(charToFind + 1));
                            }
                            // C
                            else if (grid[row - 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }

                            // E
                            else if (grid[row][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col + 1, word, word.charAt(charToFind + 1));
                            }

                    }
                    // Letter is touching bottom right corner
                    if (row == this.noOfRows && col == this.rowLength)
                    {
                            // A
                            if (grid[row - 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // B
                            else if (grid[row - 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col, word, word.charAt(charToFind + 1));
                            }
                            // D
                            if (grid[row][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col - 1, word, word.charAt(charToFind + 1));
                            }
                    }
                    // letter is on top row of grid
                    if (row == 0 && col > 0 && col < this.rowLength)
                    {
                            // D
                            if (grid[row][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col - 1, word, word.charAt(charToFind + 1));
                            }
                            // E
                            else if (grid[row][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col + 1, word, word.charAt(charToFind + 1));
                            }
                            // F
                            else if (grid[row + 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // G
                            else if (grid[row + 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col, word, word.charAt(charToFind + 1));
                            }
                            // H
                            else if (grid[row + 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                    }
                    // Letter is on bottom row of grid
                    if (row == this.noOfRows && col > 0 && col < this.rowLength)
                    {
                            // FOR CODES SEE CHECKPLACES.TXT
                            // A
                            if (grid[row - 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // B
                            else if (grid[row - 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col, word, word.charAt(charToFind + 1));
                            }
                            // C
                            else if (grid[row - 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // D
                            else if (grid[row][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col - 1, word, word.charAt(charToFind + 1));
                            }
                            // E
                            else if (grid[row][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col + 1, word, word.charAt(charToFind + 1));
                            }
                    }
                    // Letter is on Leftmost column of grid
                    if (col == 0 && row > 0 && row < this.noOfRows)
                    {
                            // B
                            if (grid[row - 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col, word, word.charAt(charToFind + 1));
                            }
                            // C
                            else if (grid[row - 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // E
                            else if (grid[row][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col + 1, word, word.charAt(charToFind + 1));
                            }
                            // G
                            else if (grid[row + 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col, word, word.charAt(charToFind + 1));
                            }
                            // H
                            else if (grid[row + 1][col + 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row + 1, col + 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                    }
                    // Letter is on rightmost column of grid
                    if (col == this.rowLength && row > 0 && row < this.noOfRows)
                    {
                            // A
                            if (grid[row - 1][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col - 1, word,
                                                    word.charAt(charToFind + 1));
                            }
                            // B
                            else if (grid[row - 1][col] == word.charAt(charToFind))
                            {
                                    gridCheck(row - 1, col, word, word.charAt(charToFind + 1));
                            }
                            // D
                            else if (grid[row][col - 1] == word.charAt(charToFind))
                            {
                                    gridCheck(row, col - 1, word, word.charAt(charToFind + 1));
                            }

                    }
            }

            // If word is not found
            return false;
    }

网格对象的构造函数 [如果我们需要它] 如下 -

/**
     * Constructs a new LetterGrid Object
     * 
     * @param letterGridFile
     *            the file to use
     */
    public LetterGrid(String letterGridFile)
    {
            try
            {
                    // Init Scanner
                    Scanner fileIn = new Scanner(new File(letterGridFile));
                    // Init ArrayList
                    ArrayList<String> nextLine = new ArrayList<String>(10);
                    // Read Data
                    while (fileIn.hasNextLine())
                    {
                            nextLine.add(fileIn.nextLine());
                            noOfRows++;
                    }
                    fileIn.close();

                    rowLength = nextLine.size();
                    grid = new char[noOfRows][rowLength];
                    // Add data to grid
                    for (int rowCount = 0; rowCount < noOfRows; rowCount++)
                    {

                            grid[rowCount] = (nextLine.get(rowCount).toCharArray());
                    }
            }
            // In case file name is mistyped or nonexistent
            catch (IOException exp)
            {
                    System.out.println("Oops, something went wrong.");
                    System.out.println("--> File Not Found");
            }

    }

最后，我用来搜索的参考：

Places to check             the X = current letter to check around
Row   Col  Code              A    B    C
-1    -1    A
-1     0    B                D    X    E
-1     1    C
 0    -1    D                F    G    H
 0     1    E
 1    -1    F
 1     0    G
 1     1    H

谢谢大家的帮助=）

-Apok

Answer 1

尽管您需要添加额外的代码来限制网格范围内的搜索，但这样的事情可能会奏效（这也是 C# 而不是 java，但几乎相同）

    private Point FindWordInWordSeacrh(String word)
    {
        char[,] grid = new char[10, 10];


        for (int x = 0; x < 10; x++)
        {
            for (int y = 0; y < 10; y++)
            {
                int iWOrdCharIndex = 0;
                if (grid[x,y] == word[iWOrdCharIndex])
                {
                    // if the first letter of the word is found
                    iWOrdCharIndex++;

                    // Set the direction vector to continue the search
                    for (int xDir = -1; xDir <= 1; xDir++)
                    {
                        for (int yDir = -1; yDir <= 1; yDir++)
                        {
                            // Diretion vector set so check for remaining letters of word
                            for (int iCharPos = 1; iCharPos < word.Length; iCharPos++)
                            {
                                // Check the next letters of the word along this direction vector
                                if (grid[x+xDir, y+yDir] != word[iCharPos])
                                {
                                    // break loop and chnage direction vector if looking in wrong direction 
                                    break;
                                }
                                else if (iCharPos == word.Length)
                                {
                                    // retun the starting point if word found
                                    return new Point(x, y);
                                }
                            }
                        }
                    }
                }

            }
        }
        return null;
    }

Answer 2

那么我看到的第一件事是我认为您的代码将在以下内容中计算“计算机”一词：

xxxxxxcxxxxxx
xxxxxoxxxxxxx
xxxxxmxxxxxxx
xxxxxxpuxxxxx
xxxxxretxxxxx

X 是任意字母。

我相信你需要实现一些东西来保留调用之间的搜索方向。

例如，如果您在网格中的某个点找到单词“computer”的第一个字母，然后在西北方向找到“o”，那么您的代码应继续在 NW 方向搜索，直到找到不在单词中的字符（或者当然，如果它撞到“墙”）