[RESOLVIDO]Comparação entre linhas, colunas e diagonais de uma matriz

Olá.

Fiz uma aplicação que testa se tenho um quadrado mágico numa matriz, mas ela diz-me sempre que o quadrado não é mágico e eu penso que o erro está nos métodos que comparam as suas linhas, colunas e diagonais.

Para ser um quadrado magico, a soma de cada linha, cada coluna e cada diagonal da matriz têm de dar todas o mesmo resultado.
Tentei com a seguinte matriz que o é um quadrado mágico e o programa errou porque me disse que ela não é um quadrado mágico:
[list]8 1 6
3 5 7
4 9 2[/list]

E aqui deixo o código:

import java.util.Scanner;

public class PL7exComp1 {

    public static void main(String[] args) {
        Scanner ler = new Scanner(System.in);
        System.out.println("Insira a capacidade de linhas/colunas da matriz quadrada: ");
        int n = ler.nextInt();
        int[][] m = new int[n][n];
        boolean flag;
        m = preenximento(n);
        flag = verificacao(m, n);
        if (flag == true) {
            System.out.println("A matriz é um quadrado mágico!");
        } else {
            System.out.println("A matriz não é um quadrado mágico!");
        }
    }

    public static int[][] preenximento(int n) {
        Scanner ler = new Scanner(System.in);
        int[][] mat = new int[n][n];
        System.out.println("Preenximento da matriz quadrada:");
        for (int i=0; i<n; i++) {
            for (int k=0; k<n; k++) {
                System.out.println("Insira um valor para a posição [" + i + "][" + k + "] da matriz: ");
                mat[i][k] = ler.nextInt();
            }
        }
        return mat;
    }

    public static boolean verificacao(int[][] m, int n) {
        int[] linhas = new int[n];
        int[] colunas = new int[n];
        int[] diagonais1 = new int[n];
        int[] diagonais2 = new int[n];
        int vlinhas=0, vcolunas=1, vdiagonais1=2, vdiagonais2=3;
        boolean flagLinhas = true, flagColunas = true, flagDiagonais1 = true, flagDiagonais2 = true, flag = false;
        linhas = linhas(m, n);
        colunas = colunas(m, n);
        diagonais1 = diagonais1(m, n);
        diagonais2 = diagonais2(m, n);
        //verificação das linhas
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (linhas[i] != linhas[j]) {
                    flagLinhas = false;
                }
            }
            vlinhas=linhas[i];
        }
        //verificação das colunas
        for (int k = 0; k < n; k++) {
            for (int j = k + 1; j < n; j++) {
                if (colunas[k] != colunas[j]) {
                    flagColunas = false;
                }
            }
            vcolunas=colunas[k];
        }
        //verificação das diagonais1
        for (int k = 0; k < n; k++) {
            for (int z = k + 1; z < n; z++) {
                if (diagonais1[k] != diagonais1[z]) {
                    flag = false;
                }
            }
            vdiagonais1=diagonais1[k];
        }
        //verificação das diagonais
        for (int k = n; k <= 0; k--) {
            for (int z = n - 1; z <= 0; z--) {
                if (diagonais2[k] != diagonais2[z]) {
                    flag = false;
                }
            }
            vdiagonais2=diagonais2[k];
        }
        if(flagLinhas==true && flagColunas==true && flagDiagonais1==true && flagDiagonais2==true){
            if(vlinhas==vcolunas && vlinhas==vdiagonais1 && vlinhas==vdiagonais2){
                flag= true;
            }
        }
        return flag;
    }

    public static int[] linhas(int[][] m, int n) {
        int[] linhas = new int[n];
        //linhas
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                linhas[j] = m[i][j];
            }
        }
        return linhas;
    }

    public static int[] colunas(int[][] m, int n) {
        int[] colunas = new int[n];
        int i = 0;
        //colunas
        for (int j = 0; j < n; j++) {
            for (i = 0; i < n; i++) {
                colunas[j] = m[i][j];
            }
        }
        return colunas;
    }

    public static int[] diagonais1(int[][] m, int n) {
        int[] diagonais1 = new int[n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    diagonais1[i] = m[i][j];
                }
            }
        }
        return diagonais1;
    }

    public static int[] diagonais2(int[][] m, int n) {
        int[] diagonais2 = new int[n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    diagonais2[i] = m[i][j];
                }
            }
        }
        return diagonais2;
    }
}

Se poderem ajudar fico agradecido.
Obrigado e Abraço

Para o exemplo apresentado:

- no procedimento linhas(. . .) o resultado é [4],[9],[2]
- no procedimento colunas(. . .) o resultado é [4],[9],[2]
- no procedimento diagonais1(. . .) o resultado é [8],[5],[2] ==> CORRETO !
- no procedimento diagonais2(. . .) o resultado é [8],[5],[2]

Sugestão:

// - - > altere de:
 int[] colunas = new int[n]; 
 int[] linhas = new int[n];   
  
// - - > para:
 int[][] colunas = new int[n][n];   
 int[][] linhas = new int[n][n];   

// - - > observe que  linhas será idêntica à matriz
// - - > e, refaça os procedimentos de preenchimento e verificação

// - - > altere o procedimento diagonais2(. . .) para:
   public static int[] diagonais2(int[][] m, int n) {   
        int[] diagonais2 = new int[n];   
        int j =  n;    
        for (int i = 0; i < n; i++) {   
            j--;
            diagonais2[i] = m[i][j];   
            }   
        }   
        return diagonais2;   
    }  

// - - > simplifique o procedimento diagonais1(. . .) para:
 public static int[] diagonais1(int[][] m, int n) {   
        int[] diagonais1 = new int[n];   
        for (int i = 0; i < n; i++) {   
            diagonais1[i] = m[i][i];   
            }   
        }   
        return diagonais1;   
    }

3 Respostas

Topicos relacionados