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

Question

I'm trying to search for a string in a char[][] array.

I think the problem with my code is that when charArray[k] is found to be a match, charArray[k+1] needs to match puzzle[i][j+1] and continues to match for the entire charArray.length.

But because the length of the given word is not predetermined, i can't write super complicated multiple nested for loops for each value of the word.

also, when my code finds charArray[k], firstly it doesn't increase the value of k, also it doesn't begin the search of next character from where it left off.

I feel like the solution might be with having two methods exchange information between? or a recursive method nested within the first for loop somehow?

please help!

thank you!

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

If you only have horizontal words then this code will do:

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;
    }
}

Do you also need to check for vertical words?

Answer 2

There is two thing at code.

• First is that why do you continue because you found a equality, you should iterate on array.(when you do continue, iteration exit loop. " if ( puzzle[i][j] == charArray[k])"

• The second thing is you are not increase 'k' index. In order to make a right comparison, you should increase two index. ( if ( puzzle[i][j] == charArray[k++])).

Please try this code. You don't need outer loop ."for(int k = 0; k < charArray.length; 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 3

Let be quick and dirty using Stream :

First, iterate the array :

Arrays.stream(array)

Then, search for any matched using Arrays.equals , you will need to get the char[] of your String

char[] search = word.toCharArray();

Let use anyMatch to tell us if there is at least one match in that Stream :

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

The Predicate used here simply use Arrays.equals to will check if both char[] are the sames. This is simple and doesn't required to instantiate String .

Full code :

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

Your solution

First, you don't want to iterate the word to find but the char[][] directly. For each row, you will iterate the 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;

The exit condition could probably be improved but I don't want to take too much time on that part since the comparison could be done simply using Arrays.equals :

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

Answer 4

All the answers here match if a String from String array matches a given value but I don't think that's what are you looking for :/ I've made a custom method that matches for a particular word is part of the char[][] array.

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;
}

and then for the tests like:

    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"));

output will be:

true
false
false
true
false