Java 二维布尔数组垂直、水平和对角赋值

老实说，我可能想得太多了，但是如果你有一个

布尔[8][8]

数组，其中的值为true，那么如何使所有的水平、垂直和对角值都为true呢

例如，给定[X]，如何使所有其他值也为X：

0 0 X 0 0  X  0 0
0 0 0 X 0  X  0 X
0 0 0 0 X  X  X 0
X X X X X [X] X X
0 0 0 0 X  X  X 0
0 0 0 X 0  X  0 X
0 0 X 0 0  X  0 0
0 X 0 0 0  X  0 0

现在，我可以做垂直和水平：

for(int i = 0; i < 8; i++){
    for (int l = 0; l < 8; l++){
        if (boolean[i][l]){
            for (int k = 0; k < 8; k++){
                boolean[i][k] = true;
                boolean[k][l] = true;}
            }
        }
   }

for（int i=0；i<8；i++）{
对于（int l=0；l<8；l++）{
if（布尔[i][l]）{
对于（int k=0；k<8；k++）{
布尔[i][k]=真；
布尔[k][l]=true；}
}
}
}

这里有一个完整的工作示例来解决这个问题。有关更多详细信息，请参见代码中的注释：

public class Boolean_Array
{
    private static final int SIZE = 8;

    public static void main(String[] args)
    {
        // create the boolean array
        boolean [][] boolArr = new boolean [SIZE][SIZE];

        // 1. Set the row, col of the true
        int row = 3;
        int col = 5;

        // 2. Make the vertical, horizontal and diagonals true
        for (int i = 0; i < SIZE; i++)
        {
            // Do the vertical and horizontal
            boolArr[row][i] = true;
            boolArr[i][col] = true;

            // Do the diagonals
            setDiagonol(boolArr, row - i, col - i, i); // up and to the left
            setDiagonol(boolArr, row - i, col + i, i); // up and to the right
            setDiagonol(boolArr, row + i, col - i, i); // down and to the left
            setDiagonol(boolArr, row + i, col + i, i); // down and to the right
        }

        print(boolArr);
    }

    private static void setDiagonol (boolean [][] boolArr, int row, int col, int i)
    {
        try
        {
            boolArr[row][col] = true;
        }
        catch (java.lang.ArrayIndexOutOfBoundsException aioobe)
        {
            // catching for convenience so we don't have to check the bounds
        }
    }

    private static void print (boolean [][] boolArr)
    {
        for (int i = 0; i < SIZE; i++)
        {
            for (int j = 0; j < SIZE; j++)
            {
                System.out.print(boolArr[i][j] == true ? "X " : "0 ");
            }
            System.out.println();
        }
    }
}

---

首先，在循环中，一旦找到第一个真值，就需要一个分离变量。我建议将布尔值作为for循环中的条件之一。除此之外，以下是我的做法（注意：这将放在循环中垂直/水平线的正下方）：

//正斜率对角线
如果（（i-Math.min（i，l））+k<8&（（l-Math.min（i，l））+k<8）
testArray[（i-Math.min（i，l））+k][（l-Math.min（i，l））+k]=真；
//负斜率对角线
如果（（k）<8&（（l+i）-k）>=0&（（l+i）-k）<8）
testArray[k][（l+i）-k]=真；

在本例中，两条对角线分开。对于第一条对角线，我检查以确保其位置在数组的边界内（我将稍微解释一下如何确定位置）。其次，我确定位于括号中的每个对角线的起始位置的X和Y值。最后，我通过在X和Y方向上移动K个单位（一步一步）从起始位置开始，用对角线穿过网格来找到位置。对于指向另一个方向的诊断，重复相同的操作，但X值减去K，而不是增加K，就像对角线指向相反方向一样。对于起始位置和运动的精确逻辑，可以通过摆弄位置或画出我的算法来找到

例如

放置（注意，我添加了变量以确保在找到一个真值后停止）：

boolean notFound=true；
对于（int i=0；i<8&¬Found；i++）{
对于（int l=0；l<8&¬Found；l++）{
if（testArray[i][l]）{
对于（int k=0；k<8；k++）{
testArray[i][k]=真；
testArray[k][l]=真；
如果（（i-Math.min（i，l））+k<8&（（l-Math.min（i，l））+k<8）
testArray[（i-Math.min（i，l））+k][（l-Math.min（i，l））+k]=真；
如果（（k）<8&（（l+i）-k）>=0&（（l+i）-k）<8）
testArray[k][（l+i）-k]=真；
}
notFound=false；
}
}
}

主类

public static void main(String[] args) {
    printGrid(3, 2);
    System.out.println();

    printGrid(5, 4);
    System.out.println();

    printGrid(7, 0);
    System.out.println();
}

public static void printGrid(int x, int y) {
    boolean[][] grid = new boolean[8][8];

    for (int i = 0; i < grid.length; i++) {
        for (int l = 0; l < grid[0].length; l++) {

            // horizontal and vertical
            if (x == i || y == l) {
                grid[i][l] = true;
            }

            // diagonals
            if (Math.abs(x - i) == Math.abs(y - l)) {
                grid[i][l] = true;
            }

            System.out.print(String.format("%-2s", grid[i][l] == true ? "X" : "O"));
        }

        System.out.println();
    }
}

---

代码的确切位置。它是在第三个循环内还是在第二个循环的if语句内？因为如果这个代码在第三个循环中，它就不能工作

//positive slope diagonal
if(((i - Math.min(i, l)) + k) < 8 && ((l - Math.min(i, l)) + k) < 8)
    testArray[(i - Math.min(i, l)) + k][(l - Math.min(i, l)) + k] = true;

//negative slope diagonal
if((k) < 8 && ((l + i) - k) >= 0 && ((l + i) - k) < 8)
    testArray[k][(l + i) - k] = true;

    boolean notFound = true;

    for(int i = 0; i < 8 && notFound; i++){
        for (int l = 0; l < 8 && notFound; l++){
            if (testArray[i][l]){
                for (int k = 0; k < 8; k++){
                    testArray[i][k] = true;
                    testArray[k][l] = true;

                    if(((i - Math.min(i, l)) + k) < 8 && ((l - Math.min(i, l)) + k) < 8)
                        testArray[(i - Math.min(i, l)) + k][(l - Math.min(i, l)) + k] = true;

                    if((k) < 8 && ((l + i) - k) >= 0 && ((l + i) - k) < 8)
                        testArray[k][(l + i) - k] = true;       
                }
                notFound = false;
             }
         }
     }

public static void main(String[] args) {
    printGrid(3, 2);
    System.out.println();

    printGrid(5, 4);
    System.out.println();

    printGrid(7, 0);
    System.out.println();
}

public static void printGrid(int x, int y) {
    boolean[][] grid = new boolean[8][8];

    for (int i = 0; i < grid.length; i++) {
        for (int l = 0; l < grid[0].length; l++) {

            // horizontal and vertical
            if (x == i || y == l) {
                grid[i][l] = true;
            }

            // diagonals
            if (Math.abs(x - i) == Math.abs(y - l)) {
                grid[i][l] = true;
            }

            System.out.print(String.format("%-2s", grid[i][l] == true ? "X" : "O"));
        }

        System.out.println();
    }
}

X O X O X O O O 
O X X X O O O O 
X X X X X X X X 
O X X X O O O O 
X O X O X O O O 
O O X O O X O O 
O O X O O O X O 

O O O O X O O O 
X O O O X O O O 
O X O O X O O X 
O O X O X O X O 
O O O X X X O O 
X X X X X X X X 
O O O X X X O O 
O O X O X O X O 

X O O O O O O X 
X O O O O O X O 
X O O O O X O O 
X O O O X O O O 
X O O X O O O O 
X O X O O O O O 
X X O O O O O O 
X X X X X X X X