Java, замена 2D-матрицы по диагонали со средней линией

Question

Я хотел бы задать несколько глупых вопросов, которые действительно беспокоят меня довольно долго, и я не смог найти каких-либо решений по этому вопросу.

Например, у меня есть 2D-массив Java

String arraylist numberSeq[][];

внутри списка массивов, есть число от 1 до 25,

numberSeq[0][0] = 1, [0][1] = 2, [0][2] = 3 , [0][3] = 4 , [0][4] = 5
numberSeq[1][0] = 6, [1][1] = 7, [1][2] = 8 , [1][3] = 9 , [1][4] = 10
......
numberSeq[4][0] = 21,[4][1] = 22,[4][2] = 23, [4][3] = 24, [4][4] = 25

Так что число будет похоже на

1  2  3  4  5
6  7  8  9  10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

После выполнения перестановки диагоналей, я хочу, чтобы выводбыть как

25 20 15 10 5
24 19 14 9  4
23 18 13 8  3
22 17 12 7  2
21 16 11 6  1

Могу ли я знать, как я могу добиться того, что с помощью только можно объявить 1 локальную переменную ??

Если 1 локальная переменная не достижима, попробуйте, сколько будет объявлено минимальноелокальная переменная я могу добиться этого ??

Спасибо заранее ...

Answer 1

следующий цикл выполнит диагональный обмен как в вашем вопросе:

    int n=5;
    int[][] newmat = new int[5][5];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            newmat[(n-1) - j][(n-1)- i] = matrix[i][j];
        }
    }

Answer 2

Вы можете сделать это, создав другой тео-мерный массив, выполнив итерацию вашего первого в правильном порядке и разместив его в новом.

public class MyClass {
    public static void main(String args[]) {

        int dimension = 5;

        int[][] numberSeq = new int[dimension][dimension];

        numberSeq[0][0] = 1; numberSeq[0][1] = 2;numberSeq[0][2] = 3;numberSeq[0][3] = 4;numberSeq[0][4] = 5;
        numberSeq[1][0] = 6; numberSeq[1][1] = 7;numberSeq[1][2] = 8;numberSeq[1][3] = 9;numberSeq[1][4] = 10;
        numberSeq[2][0] = 11;numberSeq[2][1] = 12;numberSeq[2][2] = 13;numberSeq[2][3] = 14;numberSeq[2][4] = 15;
        numberSeq[3][0] = 16;numberSeq[3][1] = 17;numberSeq[3][2] = 18;numberSeq[3][3] = 19;numberSeq[3][4] = 20;
        numberSeq[4][0] = 21;numberSeq[4][1] = 22;numberSeq[4][2] = 23;numberSeq[4][3] = 24;numberSeq[4][4] = 25;

        int[][] flippedSeq = new int[dimension][dimension];

        // This is the flipping part
        for(int i = 0; i < dimension; i++)
        {
            for(int j = 0; j < dimension; j++)
            {
                flippedSeq[i][j] = numberSeq[dimension-1-j][dimension-1-i];
            }
        }

        PrintMatrix(numberSeq);
        System.out.println();
        PrintMatrix(flippedSeq);


    }

    public static void PrintMatrix(int[][] mat)
    {
        for(int i = 0; i < mat.length; i++)
        {
            for(int j = 0; j < mat[i].length; j++)
                System.out.print(mat[i][j] + " ");
            System.out.println();
        }
    }
}

Надеюсь, это то, что вы имели в виду "1 локальная переменная".

Вывод:

1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20 
21 22 23 24 25 

25 20 15 10 5 
24 19 14 9 4 
23 18 13 8 3 
22 17 12 7 2 
21 16 11 6 1 

Answer 3

Это должно помочь.так что да, возможен обмен с одной локальной переменной.

public swapDiagonally(int[][] mtx) {
  for(int i = 0 ;i< mtx.length; i++){
     for(int j = 0; j < mtx[0].length - i; j++){ 
        int temp = mtx[i][j];
        mtx[j][i]; = mtx[mtx.length-1-i][mtx[0].length-1-j];
        mtx[mtx.length-1-i][mtx[0].length-1-j] = temp;
     }
  } 
}

По сути, я пересекаю «общее количество строк - N» для каждого N-го столбца, таким образом, помогая мне пройти эту структуру:

 1 2 3 4
 1 2 3
 1 2
 1

для массива 4x4 !!!