遍历2D数组； 魔术广场

Question

For my summer Java class, I'm working on a program that detects whether the elements in an array are a magic square. I'm not entirely sure how to properly iterate through the array to be able to calculate the total of the separate columns and rows to determine if the array is a magic square. We were given the code for the sum of the down diagonal, but I'm unsure how to approach the up diagonal, rows and columns. Here is a snippet of my code so far.

public class MagicSqaure
{
    public static void main(String[] args)
    {
        int[][] array = 
        {
            {2, 7, 6},
            {9, 5, 1},
            {4, 3, 8}
        };  

public static int getSumOfDownDiagonal(int[][] array)
{
    int total = 0;
    for (int i = 0; i < array.length; i++)
    {
        total += array[i][i];
    }
    return total;
}       

Answer 1

Since it is a class, I can only provide help on how to accomplish traversing through the rows, columns and up diagonal, but providing **no code at all*. It's up to you to do the right implementation, otherwise you're not learning but copying/pasting/becoming a zombie coder.

• To traverse each row, go through the elements of your array of arrays like this:

   total += array[i][j]; 

  Where i won't change but j changes.

• To traverse each column, go through the elements of your array of arrays like this:

   total += array[i][j]; 

  Where i changes but j won't change.

• To traverse the up diagonal, go through the elements of your array of arrays like this:

   total += array[i][j]; 

  Where i starts at the last possible index of the array of arrays and j starts at the first index of the array of arrays.

Answer 2

Whenever I need to derive equations for certain behaviors, I just write a few of the answers out manually then look for patterns. First let's assume this is how we access items in the array:

       column
        0 1 2
       --------
    0 | 2 7 6
row 1 | 9 5 1
    2 | 4 3 8

(Using array[column][row])

Now let's get the indices for the columns:

column 0 = {2, 9, 4} = array[0][0], array[0][1], array[0][2]
column 1 = {7, 5, 3} = array[1][0], array[1][1], array[1][2]

And here are the rows:

row 0 = {2, 7, 6} = array[0][0], array[1][0], array[2][0]
row 1 = {9, 5, 1} = array[0][1], array[1][1], array[2][1]

And here's the other diagonal:

3x3 array = {4, 5, 6} = array[0][2], array[1][1], array[2][0]
4x4 array = array[0][3], array[1][2], array[2][1], array[3][0]

Notice any patterns? For the diagonal, we start at array[0][array.length - 1] and end at array[array.length - 1][0]. This means our loop would be as follows:

int total = 0;
for (int i = 0; i < array.length; i++)
{
    total += array[i][array.length - 1 - i];
}
return total;

And to sum a column, it'd be:

int total = 0;
for (int i = 0; i < array.length; i++)
{
    total += array[column_index][i];
}
return total;

And for rows:

int total = 0;
for (int i = 0; i < array.length; i++)
{
    total += array[i][row_index];
}
return total;

EDIT: In response to downvotes and comments, I have modified the magic square code to work with row-major conventions. Oh wait, no I didn't since the code would be identical. Anyway, this is how you do it.