Calculer reflète la matrice

Question

Je suit matrice 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 

Maintenant, je veux refléter cette matrice et obtenir le résultat suivant:

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 

La matrice d'origine est représentée par une matrice de tableau 2D [ligne] [colonne]. Donc, l'idée est d'échanger les valeurs.

Ma stratégie est:

(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) 

... 

Voici mon code:

  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; 

       } 
      } 

Le code ne fonctionne pas. Des idées?

Answer 1

Vous échangez deux fois les éléments. Vous n'avez besoin d'échanger que les éléments diagonaux supérieurs (ou inférieurs). Vous pouvez faire:

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

Code In Action

Answer 2

Vous pouvez utiliser une copie de la même matrice, pour être en mesure de stocker les valeurs dans le nouveau matrice2.
(martix != matrix2) est vrai.
Maintenant, j'utiliser ce code pour inverser votre matrice:

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

Answer 3

J'ai décidé que je voudrais voir cela comme une boucle foreach donc je l'ai fait ce qui suit:

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

Je ne sais pas pourquoi mais je me sentais comme si c'était un peu plus clair que ceux qui utilisent i, j, k, etc ... Je crois que la réponse de codaddict fonctionne, cependant.