Java程序在特定测试用例上失败

Question

我写了一个java程序，它基本上和wordle一样。例如，给定2 3x3行

// Answer
AAA
BBB
CCC
// Guess
AYY
AAA
ZZZ

如果猜测与答案匹配（在本例中，索引[0][0]），则将其标记为“绿色”
如果猜测与确切位置的答案不匹配，但它是有效的（例如，答案[1][0]处的答案与猜测[1][0]处的答案不匹配，但是猜测[0][1]处的答案），则将被计为“黄色”

这是我目前拥有的代码。它适用于这个测试用例和除一个之外的所有其他测试用例。我似乎没能抓住我的错误。

import java.util.Scanner;

// Currently test case 6 not working

public class test {
    public static void main(String[] args) throws FileNotFoundException {
        Scanner io = new Scanner(System.in);
        int green = 0, yellow = 0;
        char[][] answer = new char[3][3];
        char[][] guess = new char[3][3];
        {
            String tempString = io.next();
            for (int i = 0; i < 3; i++) {
                answer[0][i] = tempString.charAt(i);
            }
            tempString = io.next();
            for (int i = 0; i < 3; i++) {
                answer[1][i] = tempString.charAt(i);
            }
            tempString = io.next();
            for (int i = 0; i < 3; i++) {
                answer[2][i] = tempString.charAt(i);
            }

            tempString = io.next();
            for (int i = 0; i < 3; i++) {
                guess[0][i] = tempString.charAt(i);
            }
            tempString = io.next();
            for (int i = 0; i < 3; i++) {
                guess[1][i] = tempString.charAt(i);
            }
            tempString = io.next();
            for (int i = 0; i < 3; i++) {
                guess[2][i] = tempString.charAt(i);
            }
            //System.out.println(Arrays.deepToString(answer));
            //System.out.println(Arrays.deepToString(guess));
        }

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (answer[i][j] == guess[i][j]) {
                    answer[i][j] = (char) -1;
                    guess[i][j] = (char) -1;
                    green++;
                }
            }
        }



        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                if (answer[i][j] != guess[i][j]) {
                    char needToFind = guess[i][j];

                    for (int k = 0; k < 3; k++) {
                        for (int l = 0; l < 3; l++) {
                            if (answer[k][l] == needToFind) {
                                yellow++;
                                guess[i][j] = (char) -1;
                                answer[k][l] = (char) -1;
                                break;
                            }
                        }
                    }
                    //System.out.println("-----2"); debug here don't mind me
                    //System.out.println(Arrays.deepToString(answer));
                    //System.out.println(Arrays.deepToString(guess));
                    //System.out.println(yellow);


                }
            }
        }
        System.out.println(green);
        System.out.println(yellow);
    }

}
/*
plan
    Get input using 2d arrays
    Create 2 matrix arrays: answer and guess
    Get the values into the array
    Use for loop that loops 9 times
    If the value at answer is the same at same index in guess, green++

    Use another for loop 9 times, if the indexes are NOT the same (and is not -1), then find if another of the same value exists in another index, if so, change the answer index into -1 and yellow++;

*/

我目前并不太担心速度，它的性能与我所做的简单实现所期望的一样。

Answer 1

这是我想出来的：

public static void main(String[] args) {
    String[] guess = {"AYY","AAA","ZZZ"};
    String[] answer = {"AAA","BBB","CCC"};
        
    Stream<String> gWords = Arrays.asList(guess).stream();
    String gFlat = gWords.collect(Collectors.joining()); // "AYYAAAZZZ"
        
    Stream<String> aWords = Arrays.asList(answer).stream(); // "AAABBBCCC"
    String aFlat = aWords.collect(Collectors.joining());

    String [][] color = new String[3][3];

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            String guessLetter = Character.toString((guess[i]).charAt(j));
            if (Character.toString(answer[i].charAt(j)).equals(guessLetter)) {
                color[i][j] = "green";
            } else if (aFlat.contains(guessLetter)) {
                color[i][j] = "yellow";
            } else {
                color[i][j] = "red";
            }
        }
    }
    System.out.println();
}

程序的输出如下：

[
  [green, red, red], // for "AYY"
  [yellow, yellow, yellow], // for "AAA" 
  [red, red, red] // for "ZZZ"
]

唯一与当前索引中的字母匹配的字母是guess[0][0]guess[0][1]和guess[0][2]是红色的，因为在扁平的aFlat字符串中找不到字母Y。

guess[1][x]全部为黄色，因为字母A位于扁平的aFlat字符串上，但不在答案数组的正确索引位置。

最后，猜测[2][x]是红色的，因为字母Z在扁平化的aFlol字符串中的任何地方都找不到。