Java 在 char[][] 数组中搜索字符串

Question

我正在尝试在 char[][] 数组中搜索字符串。

我认为我的代码的问题是，当发现 charArray[k] 匹配时， charArray[k+1] 需要匹配 puzzle[i][j+1] 并继续匹配整个 charArray .长度。

但是因为给定单词的长度不是预先确定的，所以我不能为单词的每个值编写超级复杂的多重嵌套for循环。

另外，当我的代码找到 charArray[k] 时，首先它不会增加 k 的值，也不会从中断处开始搜索下一个字符。

我觉得解决方案可能是使用两种方法交换信息？还是以某种方式嵌套在第一个 for 循环中的递归方法？

请帮忙！

谢谢！

public static Boolean search(char[][] puzzle, String word) {

    char[] charArray = word.toCharArray();

    //search array

    for(int k = 0; k < charArray.length; k ++) {

        for (int i = 0; i < puzzle.length; i++) {
            for(int j = 0; j < puzzle[i].length; j++) {
                if ( puzzle[i][j] == charArray[k])
                    continue;

            }
        }
    }
    return true;

}

Answer 1

如果字符串数组中的字符串与给定值匹配，则此处的所有答案都匹配，但我认为这不是您要查找的内容：/ 我已经创建了一个自定义方法，该方法与特定单词匹配是字符的一部分[][] 数组。

public static Boolean wordExistsInCharArray(char[][] puzzle, String word) {

    char[] charArray = word.toCharArray();

    //search array for words only! A word is defined when there is a whitespace on both sides or start/end of input.

    int currentWordIndex, charArrayIndex;

    for (int i = 0; i < puzzle.length; i++) {
        currentWordIndex = 0;
        charArrayIndex = 0;
        for (int j = 0; j < puzzle[i].length; j++) {
            if (puzzle[i][j] == ' ') { //word has ended and we need to check if it matches the one we are looking for.
                currentWordIndex = 0;
                if (charArrayIndex == charArray.length) {
                    return true; // all the characters in the word were presented in current puzzle row. You now have both i, j indexes.
                }
                charArrayIndex = 0;
            } else {
                currentWordIndex++; // extend current word length with one character
                if (currentWordIndex - 1 == charArrayIndex) { // check if current word length and parsed characters length are equal otherwise just continue
                    if (charArrayIndex < charArray.length && charArray[charArrayIndex] == puzzle[i][j]) { // test if next character from charArray matches current word character
                        charArrayIndex++; // extend charArrayIndex if there is a match
                    } else {
                        charArrayIndex = 0; // reset charArrayIndex since there is no match or current word length is bigger than needed.
                    }
                } else {
                    continue;
                }
            }
        }
        if (charArrayIndex == charArray.length) { // in the case when the puzzle[i] has ended and we did not check if we have any occurrence
            return true; // all the characters in the word were presented in current puzzle row. You now have both i, j indexes.
        }
    }
    return false;
}

然后进行如下测试：

    char[][] puzzle1 = new char[][] {
            {'f', 'o', 'o', ' ', 'b', 'a', 'r'},
            {'f', 'o', 'o', ' ', 'b', 'u', 'z'},
            {'f', 'o', 'o', ' ', 'f', 'i', 'g', 'h', 't', 'e', 'r'}
    };

    char[][] puzzle2 = new char[][]{
            {'f', 'o', 'o', ' ', 'b', 'a', 'r'},
            {'f', 'o', 'o', ' ', 'b', 'u', 'z'},
            {'f', 'o', 'o', ' ', 'f', 'i', 'g', 'h', 't', 'e', 'r', 'e', 'u', 'r', 'o'}
    };

    char[][] puzzle3 = new char[][] {
            {'f', 'o', 'o', ' ', 'b', 'a', 'r'},
            {'f', 'o', 'o', ' ', 'b', 'u', 'z'},
            {'f', 'o', 'o', ' ', 'e', 'u', 'r', 'o', 'f', 'i', 'g', 'h', 't', 'e', 'r'}
    };

    char[][] puzzle4 = new char[][] {
            {'m', 'o', 't', 'h', ' ', 'i', 's', ' ', 'n', 'o', 't', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'w', 'o', 'r', 'd'}
    };

    char[][] puzzle5 = new char[][] {
            {'I', ' ', 'l', 'o', 'v', 'e', ' ', 'm', 'y', ' ', 'm', 'o', 't', 'h', 'e', 'r', ' ', 'f', 'o', 'r', ' ', 'r', 'e', 'a', 'l'}
    };

    System.out.println(wordExistsInCharArray(puzzle1, "fighter"));
    System.out.println(wordExistsInCharArray(puzzle2, "fighter"));
    System.out.println(wordExistsInCharArray(puzzle3, "fighter"));

    System.out.println(wordExistsInCharArray(puzzle4, "moth"));
    System.out.println(wordExistsInCharArray(puzzle5, "moth"));

输出将是：

true
false
false
true
false

Answer 2

使用Stream 让我们变得又快又脏：

首先，迭代数组：

Arrays.stream(array)

然后，使用Arrays.equals 搜索任何匹配，您将需要获得String 的char[]

char[] search = word.toCharArray();

让我们使用anyMatch 告诉我们Stream 中是否至少有一个匹配项：

.anyMatch(a -> Arrays.equals(a, search));

这里使用的Predicate 只是使用Arrays.equals 来检查两个char[] 是否相同。这很简单，不需要实例化String。

完整代码：

public static boolean search(char[][] array, String word){
    char search = word.toCharArray();
    return Arrays.stream(array)
                 .anyMatch(a -> Arrays.equals(a, search));
}

您的解决方案

首先，您不想迭代单词来查找，而是直接查找char[][]。对于每一行，您将迭代 charArray。

for (int i = 0; i < puzzle.length; i++) {
    //If both length don't match, this can't be good.
    if(puzzle[i].length == charArray.length){
        //Check both array char by char 
        for(int k = 0; k < charArray.length; k++) {
            if (puzzle[i][j] != charArray[k])
                break; //doesn't match, skip that row
            }

            if (charArray.length - 1 == k){ return true; }
        }
    }
}
//No match found
return false;

退出条件可能会得到改善，但我不想在这部分花费太多时间，因为可以简单地使用 Arrays.equals 进行比较：

for (int i = 0; i < puzzle.length; i++) {
    if(Arrays.equals(puzzle[i], charArray)
        return true;
}
//No match found
return false;

Answer 3

代码中有两件事。

• 首先，你为什么要继续，因为你发现了一个相等，你应该迭代数组。（当你继续时，迭代退出循环。“ if (uzzle[i][j] == charArray[k ])"

• 第二件事是你没有增加'k'索引。为了进行正确的比较，您应该增加两个索引。 ( if (拼图[i][j] == charArray[k++]))。

请尝试此代码。你不需要外循环 ."for(int k = 0; k

public static void main(String[] args) {
    //Found case
    char[][] puzzle = {{'b','o','o','k'}, {'a','p','p','l','e'}, {'t','a','b','l','e'}};
    String word = "apple";
    System.out.println("result: " + search(puzzle, word));
    //Output is-> result: true

    //Not Found case
    char[][] puzzle2 = {{'b','o','o','k'}, {'a','p','p','l','e','e'}, {'t','a','b','l','e'}};

    System.out.println("result: " + search(puzzle2, word));
    //Output is-> result: false
}

public static Boolean search(char[][] puzzle, String word) {

    char[] charArray = word.toCharArray();

    //search array

    for (int i = 0; i < puzzle.length; i++) {
        for(int j = 0; j < puzzle[i].length && j < charArray.length; j++) {
            //when not equal character or lengths are not equal break loop
            if ( puzzle[i][j] != charArray[j] || puzzle[i].length != charArray.length)
                break;
            //Equal and all characters compared
            else if( j + 1 == puzzle[i].length){
                return true;
            }

        }
    }
    return false;

}

Answer 4

如果你只有水平词，那么这段代码就可以了：

public class Test {

    private static char[][] puzzle = {
            { 'a' ,'z', 'e'},
            { 'a' ,'z', 'f','g'},
            { 'a' ,'z', 't', 'k','m'},
            { 'a' ,'z', 'k'}
    };

    public static void main(String[] args) {
        System.out.println(search(puzzle, "azh"));
        System.out.println(search(puzzle, "azgg"));
        System.out.println(search(puzzle, "azfg"));
        System.out.println(search(puzzle, "aztkm"));
    }

    public static Boolean search(char[][] puzzle, String word) {
        for (int i = 0; i < puzzle.length; i++) {
            String puzzleWord = new String(puzzle[i]);
            if (word.equals(puzzleWord)) {
                return true;
            }
        }
        return false;
    }
}

你还需要检查垂直词吗？