Question

我正在使用Stanford的cs106a课程自学Java。目前，我在《 Java的艺术与科学》一书的第10章。问题是写一个3x3的魔方。练习：

您必须编写一个3x3数组
数组的每一边（魔方）必须等于15

问题：
我写的程序工作正常，作业完成，这个问题是自学的。作为一个初学者，我想改进方法SumOfSides()，使其更小，更高效。我尝试用这种方法迭代数组，但是仍然有问题。有办法提高效率吗？

public void run() {
    //set the font
    setFont("Helvetica-40");


    //fill the array
    fillArray();

    //sum up all sides 
    SumOfSides();

    //check if all of the sides in the magic square array equal 15: 
    checkSides(mSqr);

    //I used this for debugging purposes only:
    //showSides();

}

//for debugging purposes:
public void showSides() {

    println(sumRight0);
    println(sumRight1);

    println(sumRight2);
    println(sumBottom0);
    println(sumBottom1);
    println(sumBottom2);
    println(sumDiagonalUp);
    println(sumDiagonalDown);


}

public void SumOfSides() {
    sumRight0 = mSqr[0][0] + mSqr[0][1] + mSqr[0][2];
    sumRight1 = mSqr[1][0] + mSqr[1][1] + mSqr[1][2];
    sumRight2 = mSqr[2][0] + mSqr[2][1] + mSqr[2][2];

    sumBottom0 =mSqr[0][0] + mSqr[1][0] + mSqr[2][0];
    sumBottom1 =mSqr[0][1] + mSqr[1][1] + mSqr[2][1];
    sumBottom2 =mSqr[0][2] + mSqr[1][2] + mSqr[2][2];

    sumDiagonalUp = mSqr[2][0] + mSqr[1][1]+ mSqr[0][2];

    sumDiagonalDown = mSqr[0][0] + mSqr[1][1] + mSqr[2][2];

}

/*This predicate method checks if the sides
  of the array add up to 15: */

public boolean checkSides(int[][] myArray) {

    if (sumRight0 ==15 && sumRight1 ==15&& sumRight2==15 && sumBottom0==15&& sumBottom1==15&&
         sumBottom2==15&& sumDiagonalUp==15&&sumDiagonalDown==15) {
        println("True, this is a Magic Square");
        return true;
    } else {
        println("False, the sides do not equal 15");
        return false;
    }

}

public void fillArray() {

    int num =0;
    for(int row=0; row <3; row++) {

        for (int col=0; col<3; col++) {
            num=readInt("");
            mSqr[row][col]=num;
        }
    }

    /*Test array values here to see
     * if they were entered correctly.
     */
    //println(mSqr[1][2]); //should be 6
    //println(mSqr[2][0]); //should be 7

}


    //instance variables: 
    int[][] mSqr= new int[3][3];

    List<List<Integer>> new1 = new ArrayList<>();

    private int sumRight0;
    private int sumRight1;
    private int sumRight2;
    private int sumBottom0;
    private int sumBottom1;
    private int sumBottom2;

    private int sumDiagonalUp;
    private int sumDiagonalDown;

}

Answer 1

也许唯一的事情就是可读性。您可以将其取值并将其移入更具可读性的变量中：

int topLeft = mSqr[0][0];
int topMid = mSqr[0][1];
...
int sumLeft = topLeft + midLeft + bottomLeft;
int sumRight = topRight = midRight + bottomRight;
...

要解决您使它变小的担忧，我认为，如您所提到的，将6个和3个值进行加和运算，将和转换成循环肯定不值得。此外，每个和的每个项对于一个或两个其他和是公共的，这没有太多的重叠。如果您执行的总和较大（总和中的术语数量较多，而不是总价值），那么就可读性/ SLOC参数而言，这是值得的。

假设您确实仍然想进行循环，则可以执行类似的操作

 sumLeft = 0;
 sumRight = 0;
 sumTop = 0;
 sumBottom = 0;
 sumDiagonalUp = 0;
 sumDiagonalDown = 0;
 for(int i = 0; i < mSqr.length; i++) {
     for(int j = 0; j < mSqr[i].length; j++) {
         if (i == 0) {
            sumLeft += mSqr[i][j];
         }
         if (i == mSqr.length - 1) {
            sumRight += mSqr[i][j];
         }
         if (j == 0) {
            sumTop += mSqr[i][j];
         }
         if (j == mSqr[i].length) {
            sumBottom += mSqr[i][j];
         }
         if (i == j) {
            sumDiagonalDown += mSqr[i][j];
         }
         if (i + j == mSqr.length - 1) {
            sumDiagonalUp += mSqr[i][j];
         }
     }
 }

循环仅在大型魔术方块上提供好处。另外，我对您的描述与您的实现感到困惑。似乎您正在对每一行和每一列以及正方形的两个对角线求和，而不是对4个边和对角线求和。

如何压缩数组的原始整数数据？

1 个答案: