Как сжать примитивные целочисленные данные для массива? - PullRequest
Новая
       10

Как сжать примитивные целочисленные данные для массива?

0 голосов
/ 13 сентября 2018

Я учу себя Java, используя курс cs106a из Стэнфорда. В настоящее время я нахожусь на 10-й главе книги "Искусство и наука о Яве". Проблема в том, чтобы написать магический квадрат 3х3. Упражнение:

  1. Вы должны написать массив 3x3
  2. Каждая сторона массива (Магический квадрат) должна равняться 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;

}

1 Ответ

0 голосов
/ 13 сентября 2018

Возможно, единственное, что читается. Вы можете взять значения и переместить их в более читаемые переменные: 

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

Петли дают преимущество только на больших магических клетках. Также меня смущает ваше описание, противопоставленное вашей реализации. Кажется, вы суммируете каждую строку и столбец, а также две диагонали квадрата, в отличие от четырех сторон и диагоналей.

...