JAVA - How to compare columns of an int[][] array

Question

I have to compare the rows and columns of an array and know if they repeat themselves.

To compare the lines, it was "easy", but I’m picking to compare the columns.

To solve temporarily I am transposing the matrix, ie transforming the rows into columns and columns in row,s to be able to use the same reasoning of row comparison. I would like a more elegant solution, because it seems to gambiarra.

import java.util.Arrays;

public class ValidaLinhasColunas {

    public static void main(String[] args) {

        // MATRIZ PARA TESTE
        // As linhas 0 e 5 sao iguais
        // As colunas 1 e 3 sao iguais
        int[][] matriz = {{0, 4, 1, 4, 0, 0}, 
                          {0, 6, 1, 6, 3, 0},
                          {0, 3, 1, 3, 0, 8}, 
                          {1, 7, 0, 7, 0, 1},
                          {0, 5, 0, 5, 1, 0},
                          {0, 4, 1, 4, 0, 0}};
            
        // Vai ser passado em parametro para os metodos 
        int linhaParaComparar = 0;
        int colunaParaComparar = 1;

        compararLinhas(matriz, linhaParaComparar);  
        compararColunas(matriz, colunaParaComparar);
    }


    /**
     * Compara a linhas passada como parametro com as demais da matriz
     * 
     * @param matriz
     * @param linhaParaComparar
     */
    public static void compararLinhas(int[][] matriz, int linhaParaComparar) {

        for (int i = 0; i < matriz.length; i++) {

            // Compara linha passada em parametro com as outras da matriz 
            // (excluindo a passada em paramentro).
            if(Arrays.equals(matriz[linhaParaComparar], matriz[i]) 
                    && matriz[linhaParaComparar] != matriz[i]) {

                System.out.println("A linha " + linhaParaComparar + " é igual à " + i);
            }
        }
    }

    /**
     * Compara a coluna passada como parametro com as demais da matriz
     * 
     * MAS ANTES 
     * 
     * Transforma as linhas da matriz passada em parametro em colunas e as
     * colunas em linhas para efetuar a validacao.
     * 
     * @param matriz
     * @param colunaParaComparar
     */
    public static void compararColunas(int[][] matriz, int colunaParaComparar) {

        // Matriz temporaria tera como quantidade de linhas, a quantidade de colunas
        // da matriz passada em parametro. E tera a quantidade de colunas da matriz
        // passada em parametro.

        int[][] matrizTemp = new int[matriz[0].length][matriz.length];

        // Transformando linhas da matriz original em colunas na matriz temporaria
        // e colunas da matriz original em linhas na matriz temporaria
        for (int i = 0; i < matrizTemp.length; i++) {
            for (int j = 0; j < matrizTemp.length; j++) {

                matrizTemp[i][j] = matriz[j][i];

                //System.out.print(matrizTemp[i][j] + " ");
            }
        }

        // Mesmo processo do método "compararLinhas". Poderia ter sido chamado
        // aqui, mas por enquanto mantido assim
        for (int i = 0; i < matrizTemp.length; i++) {

            if(Arrays.equals(matrizTemp[colunaParaComparar], matrizTemp[i]) && matrizTemp[colunaParaComparar] != matrizTemp[i]) {

                System.out.println("A coluna " + colunaParaComparar + " é igual à " + i);
            }
        }
    }
    
    
}

Answer 1

If you give up using the utility method Arrays.equals(), can implement the method comparedColumns comparing the elements of each column one by one:

public static void compararColunas(int[][] matriz, int colunaParaComparar) {


    for (int c = 0; c < matriz.length; c++) {
        if (colunaParaComparar != c) {
            boolean iguais = true;

            for (int l = 0; l < matriz.length; l++) {
                if (matriz[l][colunaParaComparar] != matriz[l][c]) {
                    iguais = false;
                    break;
                }
            }
            if (iguais) {
                System.out.println("A coluna " + colunaParaComparar + " é igual à " + c);
            }
        }
    }
}

Answer 2

Note: for the code below, I am assuming that the matrix is with the correct dimensions. I say this because there are actually no matrices in Java: what we have are arrays of arrays (an array in which each element is another array), and there is no way to force everyone to be the same size (other languages have this feature, example). Anyway, I’m assuming that in fact all arrays that represent lines have the same size, so I’m not doing any size check.

---

I suggest we modify the code a little bit. For example, instead of a method that "does everything" for all rows and another that does everything for all columns, make a method that knows how to compare only 2 rows:

// retorna true se as linhas "lin1" e "lin2" são iguais, false se forem diferentes
public static boolean linhasIguais(int[][] matriz, int lin1, int lin2) {
    return Arrays.equals(matriz[lin1], matriz[lin2]);
}

And another to compare only 2 columns:

// retorna true se as colunas "col1" e "col2" são iguais, false se forem diferentes
public static boolean colunasIguais(int[][] matriz, int col1, int col2) {
    for (int[] linha : matriz) { // para cada linha da matriz, os elementos das colunas col1 e col2 devem ser iguais
        if (linha[col1] != linha[col2]) {
            // achei um elemento diferente, não preciso continuar verificando o resto
            return false;
        }
    }
    // se chegou até aqui, é porque todos são iguais
    return true;
}

To compare lines is simple, as each row is an array of int, just use what you already have ready.

For columns, there is no direct method, but it is not so complicated: in each row of the matrix, the column element i will be in position i of this line (i.e., in the position i array). Then just go through all rows of the matrix and see if the elements of the given positions are equal.

If I find a different one, I can return false immediately (because if I’ve already found a different one, I don’t need to check the rest).

---

Then, just use these methods to do the search. In your case, you are searching from a specific row or column, so it would be:

int linhaParaComparar = 0;
for (int i = 0; i < matriz.length; i++) {
    if (i != linhaParaComparar && linhasIguais(matriz, i, linhaParaComparar)) {
        System.out.printf("As linhas %d e %d são iguais\n", i, linhaParaComparar);
    }
}

int colunaParaComparar = 1;
// tamanho da primeira linha é a quantidade de colunas
for (int i = 0; i < matriz[0].length; i++) {
    if (i != colunaParaComparar && colunasIguais(matriz, i, colunaParaComparar)) {
        System.out.printf("As colunas %d e %d são iguais\n", i, colunaParaComparar);
    }
}

---

But if you want, you can also look for all the rows and columns that are equal. In this case, I have to compare "all to all", then it would be 2 loops nested:

// procurar linhas iguais
for (int i = 0; i < matriz.length - 1; i++) { // vai até a penúltima
    for (int j = i + 1; j < matriz.length; j++) { // vai de "i + 1" até a última
        if (linhasIguais(matriz, i, j)) {
            System.out.printf("As linhas %d e %d são iguais\n", i, j);
        }
    }
}

// procurar colunas iguais
for (int i = 0; i < matriz[0].length - 1; i++) { // vai até a penúltima
    for (int j = i + 1; j < matriz[0].length; j++) { // vai de "i + 1" até a última
        if (colunasIguais(matriz, i, j)) {
            System.out.printf("As colunas %d e %d são iguais\n", i, j);
        }
    }
}

In this case, the first for goes from the first to the penultimate (row or column, the reasoning is the same). Then, the second for goes from i + 1 until the last. Thus, I compare the first with the second, third, etc., until the last. Then I compare the second with the third, fourth, etc., to the last, and so on.

This way I find all the rows and columns that are equal.