Рассчитать отраженную матрицу

Question

У меня следующая матрица 5x5:

11 21 31 41 51
12 22 32 42 52
13 23 33 43 53
14 24 34 44 54
15 25 35 45 55

Теперь я хочу отразить эту матрицу и получить следующий результат:

55 54 53 52 51
45 44 43 42 41
35 34 33 32 31
25 24 23 22 21
15 14 13 12 11

Исходная матрица представлена ​​ 2Dматрица [строка] [столбец] .Поэтому идея состоит в том, чтобы поменять значения.

Моя стратегия:

(1,1) with (5,5)
(1,2) with (4,5)
(1,3) with (3,5)
(1,4) with (2,5)

and

(2,1) with (5,4)
(2,2) with (4,4)
(2,3) with (3,4)
(2,4) with (2,4)

...

Вот мой код:

            for(int i = 0; i < 5; i++){
                for(int k = 0; k < 4; k++){
                    int f = matrix[i][k];
                    int s = matrix[4-k][4-i];
                    matrix[i][k] = s;
                    matrix[4-k][4-i] = f;

                }
            }

Код не работает.Есть идеи?

Answer 1

Вы меняете элементы дважды.Вам нужно поменять местами только верхние (или нижние) диагональные элементы.Вы можете сделать:

int size = arr.length;
for(int i=0;i<size;i++){
        for(int j=0;j<size-i;j++){
                int tmp = arr[i][j];
                arr[i][j] = arr[size-j-1][size-i-1];
                arr[size-j-1][size-i-1] = tmp;
        }                                                      
}

Код в действии

Answer 2

Я решил, что хотел бы видеть это как цикл foreach, поэтому я сделал следующее:

int bound = matrix.size - 1;

for (int[] row : matrix) {
    for (int theint : row) {
        //get current position; price of foreach
        cury = matrix.indexOf(row);
        curx = row.indexOf(theint);

        //verify that we're above swap line
        if (cury + curx < bound) {
            //calculate reflected position
            def newx = bound - curx;
            def newy = bound - cury;

            //do swap
            def tmp = matrix[newx][newy];
            matrix[newx][newy] = matrix[cury][curx];
            matrix[cury][curx] = tmp;
        }
    }    
}

Не знаю почему, но я чувствовал, что это было немного яснее, чем те, которые используют I, J, K, и т. д ... Я думаю, что ответ @ Codaddict работает, хотя.

Answer 3

Вы можете использовать копию той же матрицы, чтобы иметь возможность сохранять значения в новой матрице2.
(martix != matrix2) верно.
Теперь я использую этот код, чтобы перевернуть вашу матрицу:

for(int i=0; i<5; i++) {
  for(int j=0; j<5; j++) {
    matrix[i][j] = matrix2[4-j][4-i];
  }
}