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

Я изучаю Java, используя курс cs106a из Стэнфорда. Сейчас я нахожусь в главе 10 книги «Искусство и наука Java». Проблема в том, чтобы написать Magic Square 3x3. Упражнение:

  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;

}

соглашение об именовании! sumOfSides

Antoniossss 13.09.2018 21:10

Это не место для выполнения вашего задания другими.

Eklavya 13.09.2018 21:17

Если это работает, и вы хотите получить обратную связь, задайте вопрос на codereview.

LuCio 13.09.2018 21:17

Вы можете проверить суммы по горизонтали и вертикали в одном цикле (порядок изменения индексов), и вы можете быстро сломать любую сумму, отличную от 15.

Antoniossss 13.09.2018 21:17

Задание выполнено и работает, это для самообучения.

Pav 13.09.2018 21:18

@Antoniossss, как я могу улучшить соглашение об именах? Я полный новичок.

Pav 13.09.2018 21:22

Он краток и максимально эффективен. Все, что мы напишем в цикле, не будет таким эффективным ни с точки зрения скорости, ни с точки зрения потребления памяти.

Ashraff Ali Wahab 13.09.2018 21:23

Спасибо, Люцио, я сделаю это в следующий раз.

Pav 13.09.2018 21:23

Идеи соглашения об именах @OP: google.github.io/styleguide/javaguide.html#s5-naming не все в этом руководстве по стилю принято во всем мире, но соглашения об именах кажутся очень распространенными

Jeutnarg 13.09.2018 21:46
1
9
75
1
Перейти к ответу Данный вопрос помечен как решенный

Ответы 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 стороны и диагонали.

Другие вопросы по теме