Java - 二维数组检查对角数字板 [英] Java - 2D array checking diagonal number board

问题描述

目前我正在开发一个程序，该程序在 8x8 2D 阵列板中生成随机 0 和 1.我要做的是检查对角线上的所有数字是否都相同(从角开始，而不仅仅是任何对角线).

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).

示例:

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}
};

因此，如果碰巧从左上角 (0,0),(1,1)...(7,7) 开始的所有数字都是 0 或 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).

同样从这个例子中，我们可以看到从右上角的数字1"向左下角对角线重复，然后我还必须显示有一条小对角线为 1".

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.

推荐答案

已经有很多答案了.这是另一种方法.你在正确的轨道上，但没有必要通过检查对角线元素和下一个元素等等来使事情复杂化.只需用第一个对角线元素检查每个对角线元素.一旦发现差异，就停止检查！

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);

 }

通过这种方式，您仍然在 O(n) 中进行检查，并且不需要嵌套 for 循环！注意，您可以优化此代码以消除冗余，即具有单个 for 循环等.

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.

这篇关于Java - 二维数组检查对角数字板的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！