JAVA - 验证二维数组上的对角线

Question

我一直在开发这个应用程序，您需要查看是否至少有 4 个值匹配。验证必须是水平的、垂直的或对角的。

对角线验证不起作用。

 public static boolean validateDiagonal(String[] dna) {
        char[][] matrix = createMatrix(dna);
        int letterCounter = 1;

        for (int i = 0; i < dna.length; i++) {
            for (int j = 0; j < dna.length; j++) {
                //compara consecutivas desde la segunda posición
                if (j == 0) continue;
                if (i == 0) continue;

                //resetea contado si la letra de arriba no es igual a la de abajo
                if (matrix[j][i] == matrix[j - 1][i]) {
                    letterCounter++;
                    System.out.println(matrix[j][i - 1]);
                } else letterCounter = 1;

                //finaliza como verdadero si hay 4 letras iguales consecutivas
                if (letterCounter == 4) return true;

            }
        }
        return false;
    }

我不知道这是如何取值的。我的填充矩阵是：

A T G C C A 
A A G T C C 
C T A C G T 
A A C A G G 
G G C C C A 
T C C A T G 

虽然打印输出值为： 一种 一种 G C C C C G

以防万一，完整的课程是这样的：

public class Mutant {

    public static void main(String[] args) {
        String[] dna = {"ATGCCA", "AAGTCC", "CTACGT", "AACAGG", "GGCCCA", "TCCATG"};

        //imprime matriz generada
        char[][] matrix = createMatrix(dna);
        printMatrix(dna, matrix);

        boolean mutant = isMutant(dna);
        if (mutant) System.out.println("\n\n:::: MUTANTE DETECTADO ::::");
        else System.out.println("\n\nEste humano no es mutante");
    }

    /**
     * @param dna
     * @return boolean
     * Valida que el ADN corresponda a un mutante
     */
    private static boolean isMutant(String[] dna) {
        //verifica hallazgo vertical
        boolean vertical = validateVertical(dna);
        if (vertical) return true;
        //verifica hallazgo horizontal
        for (int i = 0; dna.length > i; i++) {
            boolean horizontal = validateHorizontal(dna[i]);
            if (horizontal) return true;
        }
        //verifica hallazgo oblicuo
        boolean diagonal = validateDiagonal(dna);
        if (diagonal)return true;

        return false;
    }

    /**
     * @param dna
     * @return boolean
     * Valida que un ADN coincida en forma horizontal
     */
    private static boolean validateHorizontal(String dna) {
        int letterCounter = 1;
        char[] dnaChars = dna.toCharArray();

        for (int i = 0; i < dnaChars.length; i++) {
            //compara consecutivas desde la segunda posición
            if (i == 0) continue;
            //resetea contado si la letra de la derecha no es igual a la de la izquierda
            if (dnaChars[i] == dnaChars[i - 1]) letterCounter++; else letterCounter = 1;
            //finaliza como verdadero si hay 4 letras iguales consecutivas
            if (letterCounter == 4) return true;
        }
        return false;
    }

    /**
     * @param dna
     * @return boolean
     * Valida que un ADN coincida en forma vertical
     */
    public static boolean validateVertical(String[] dna) {
        char[][] matrix = createMatrix(dna);
        int letterCounter = 1;

        for (int i = 0; i < dna.length; i++) {
            for (int j = 0; j < dna.length; j++) {
                //compara consecutivas desde la segunda posición
                if (j == 0) continue;
                //resetea contado si la letra de arriba no es igual a la de abajo
                if (matrix[j][i] == matrix[j - 1][i]) letterCounter++; else letterCounter = 1;
                //finaliza como verdadero si hay 4 letras iguales consecutivas
                if (letterCounter == 4) return true;
            }
        }
        return false;
    }

    /**
     * @param dna
     * @return boolean
     * Valida que un ADN coincida en forma oblicua
     */
    public static boolean validateDiagonal(String[] dna) {
        char[][] matrix = createMatrix(dna);
        int letterCounter = 1;

        for (int i = 0; i < dna.length; i++) {
            for (int j = 0; j < dna.length; j++) {
                //compara consecutivas desde la segunda posición
                if (j == 0) continue;
                if (i == 0) continue;

                //resetea contado si la letra de arriba no es igual a la de abajo
                if (matrix[j][i] == matrix[j][i - 1]) {
                    System.out.println(matrix[j][i - 1]);
                    letterCounter++;
                } else letterCounter = 1;

                //finaliza como verdadero si hay 4 letras iguales consecutivas
                if (letterCounter == 4) return true;

            }
        }
        return false;
    }
    /**
     * @param dna
     * @return char[][]
     * Crea una matriz con los datos ingresados
     */
    private static char[][] createMatrix(String[] dna) {
        //crea una matriz cuadrada
        char[][] matrix = new char[dna.length][dna.length];
        for (int i = 0; i < dna.length; i++) {
            for (int j = 0; j < dna[0].length(); j++) {
                //completa la matriz con el dna
                matrix[i][j] = dna[i].toCharArray()[j];
            }
        }
        return matrix;
    }

    /**
     * @param dna
     * @param matrix
     * imprime matriz
     */
    private static void printMatrix(String[] dna, char[][] matrix) {
        System.out.println("\n Matriz analizada: ");
        for (int i = 0; i < dna.length; i++) {
            System.out.println("");
            for (int j = 0; j < dna[0].length(); j++) {
                //imprime matriz generada
                System.out.print(matrix[i][j] + " ");
            }
        }
    }
}

提前非常感谢

Answer 1

所以我最终这样做了，我认为这可以大大改进。任何建议都非常欢迎

  public static boolean validateDiagonal(String[] dna) {
    char[][] matrix = createMatrix(dna);
    int letterCounter = 1;

    for (int i = 0; i < dna.length; i++) {
        for (int j = 0; j < dna.length; j++) {
            if (j == 0) continue;
            if (i == 0) continue;
            //compara con la posicion superior izquierda
            if (matrix[i - 1][j - 1] == matrix[i][j]) letterCounter++; else letterCounter = 1;
            //compara con la posicion superior derecha
            //if (matrix[i + 1][j + 1] == matrix[i][j])letterCounter++; else letterCounter = 1;
            //finaliza como verdadero si hay 4 letras iguales consecutivas
            if (letterCounter == 4) return true;

        }
    }
    return false;
}