Java - 2D array checking diagonal number board

Question

Currently I'm working on a program that generates random 0's and 1's in a 8x8 2D array board. What I have to do is check whether or not if all the numbers on the diagonal are the same (starting from the corners, not just any diagonals).

example:

int[][] array = {
    {0, 0, 0, 0, 0, 0, 0, 1},
    {0, 0, 1, 0, 1, 0, 1, 0},
    {0, 0, 0, 0, 1, 1, 1, 0},
    {0, 0, 0, 0, 1, 1, 1, 0},
    {0, 0, 1, 1, 0, 1, 1, 0},
    {0, 0, 1, 0, 0, 0, 1, 0},
    {0, 1, 0, 0, 0, 0, 0, 0},
    {1, 0, 0, 1, 1, 1, 1, 0}
};

So if by chance all the numbers starting from the top left corner (0,0),(1,1)...(7,7) are all either 0's or 1's then I have to output to the scanner indicating that "There is a major diagonal of 0" (from the example above).

Also from this example, we can see that from the top-right, the number "1" is repeated diagonally towards the bottom left, then I also have to display "There is a minor diagonal of 1".

So far I have figured out how to generate and input the numbers into the array, but I don't know how to check. This is what I have so far:

public class JavaTest{
// Main method
public static void main(String[] args) {

    int[][] array = {
        {0, 0, 0, 0, 0, 0, 0, 1},
        {0, 0, 1, 0, 1, 0, 1, 0},
        {0, 0, 0, 0, 1, 1, 1, 0},
        {0, 0, 0, 0, 1, 1, 1, 0},
        {0, 0, 1, 1, 0, 1, 1, 0},
        {0, 0, 1, 0, 0, 0, 1, 0},
        {0, 1, 0, 0, 0, 0, 0, 0},
        {1, 0, 0, 1, 1, 1, 1, 0}
    };

    // Print array numbers
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++)
            System.out.print(array[i][j] + " ");
        System.out.println();
    }
    // Print checkers

    checkMajorDiagonal(array);
}
// Check major diagonal 
public static void checkMajorDiagonal(int array[][]) {
    int majDiag;
    boolean isMatching = true;
    int row = 0;
    for(row = 0; row < array.length; row++){
        majDiag = row;
        if(array[row][row] != array[row+1][row+1]){
            isMatching = false;
            break;
        }
    }
    //If all elements matched print output
    if(isMatching)  
        System.out.println("Major diagonal is all " + array[row][row]);
    }
}

Though what I have so far is not working as I want it to be as there is an error, and I still have to do the minor diagonal. Thanks in advance.

Answer 1

There are a bunch of answers already. Here is one more way to do it. You are on the right track, but there is no need to complicate things by checking a diagonal element with the next element and so on. Just check each diagonal element with the first diagonal element. The moment you find a difference, you stop checking!

 public static void checkDiagonal(int[][] array){

     // Start with the assumption that both diagonals are consistent.
     boolean majorConsistent = true; 
     boolean minorConsistent = true;

     int length = array.length;

     int tempMajor = array[0][0];        // all elements in the Major must be equal to this
     int tempMinor = array[0][length-1]; // all elements in the Minor must be equal to this

     // Check major diagonal, and update the boolean if our assumption is wrong.
     for(int i=0; i<length; i++){ 
         if (array[i][i] != tempMajor) { //(0,0);(1,1);(3,3);...
             majorConsistent = false;
             break;
         }
     }

     // Check minor diagonal, and update the boolean if our assumption is wrong.
     for(int i=0,j=length-1; i<length; i++,j--){
         if (array[i][j] != tempMinor) { //(0,7);(1,6);(2,5);...
             minorConsistent = false;
             break;
         }
     }

     System.out.println("Major elements all same = "+majorConsistent);
     System.out.println("Minor elements all same = "+minorConsistent);

 }

This way you are still doing both the checks in O(n) and you don't need nested for loops! Note that you can refine this code to remove redundancy i.e. have a single for loop, etc.

Answer 2

If you are using Java 8 then you could potentially do this with streams rather than iterating through the values manually. That might be a more direct approach than checking against previous values.

if (IntStream.range(0, size).map(n -> array[n][n]).allMatch(n -> n == 0)) {
}

if (IntStream.range(0, size).map(n -> array[n][size-n-1]).allMatch(n -> n == 1)) {
}