Drehen Sie ein Array im Uhrzeigersinn

Question

Say I mehrdimensionales Array wie dieses:

int arr[3][3] = {{1, 2, 3}, 
       {4, 5, 6}, 
       {7, 8, 9}}; 

Ich möchte das Array im Uhrzeigersinn drehen, so dass es wie folgt aussieht:

{{7, 4, 1}, 
{8, 5, 2}, 
{9, 6, 3}}; 

Ich habe versucht, jede der Swapping Werte wiederum mit dem vorherigen Wert:

swap(&arr[0][0],&arr[0][1]); 
    swap(&arr[0][1],&arr[0][2]); 
    swap(&arr[0][2],&arr[1][2]); 
    swap(&arr[1][2],&arr[2][2]); 
    swap(&arr[2][2],&arr[2][1]); 
    swap(&arr[2][1],&arr[2][0]); 
    swap(&arr[2][0],&arr[1][0]); 
    swap(&arr[1][0],&arr[0][0]); 

Dies wurde nicht richtig gedreht. Es hat ein paar Werte dort gelassen, wo sie waren, und die anderen an die falschen Stellen gebracht.

Was mache ich falsch, und wie kann ich das erreichen?

Answer 1

Sie brauchen nicht acht Swaps, um die Matrix zu drehen, weil die letzten zwei Swaps zwei Elemente an ihren Platz bringen. Die zusätzlichen Swaps setzen ihre Operanden wieder an die falschen Stellen.

Das mittlere Element wird an seiner Stelle belassen. Die ersten vier Swaps legen vier Gegenstände an ihre neuen Plätze; Die letzten beiden Paare nehmen sich gegenseitig die neuen Spots, so dass nur zwei Swaps ausreichen, um die Rotation abzuschließen.

swap(&arr[0][0], &arr[2][0]); 
swap(&arr[0][1], &arr[1][0]); 
swap(&arr[0][2], &arr[2][0]); 
swap(&arr[1][0], &arr[2][1]); 
swap(&arr[1][2], &arr[2][1]); 
swap(&arr[2][2], &arr[2][0]); 

Demo.

Answer 2

Sie könnten beachten Sie, dass die Elemente der ersten Zeile der gedrehten Anordnung kamen aus der ersten Spalte des ursprünglichen Arrays, in umgekehrter Reihenfolge mit Bezug auf die Indizes nach der Drehung. In ähnlicher Weise stammt die zweite Zeile des gedrehten Arrays von der zweiten Spalte des ursprünglichen Arrays und so weiter. Zu diesem Zweck können Sie eine Funktion schreiben, die ein neues Array mit den entsprechenden Werten aus dem ursprünglichen Array füllt, bevor Sie die neuen Werte in das ursprüngliche Array kopieren.

Die Funktion rotate_array() iteriert über das Array rotated. Die Elemente der i ten Reihe von rotated stammen aus der i ten Spalte des Eingangsarrays a. Das j te Element der i ten Zeile von rotated ist das n-j-1 te Element der i Spalte von a. Die memcpy()-Funktion wird dann verwendet, um den Inhalt des gedrehten Arrays in das ursprüngliche Array zu kopieren.

#include <stdio.h> 
#include <string.h> 

void print_array(size_t n, int a[n][n]); 
void rotate_array(size_t n, int a[n][n]); 

int main(void) 
{ 
    size_t arr_sz = 5; 
    int arr[arr_sz][arr_sz]; 

    for (size_t i = 0; i < arr_sz; i++) { 
     for (size_t j = 0; j < arr_sz; j++) { 
      arr[i][j] = i * arr_sz + j + 1; 
     } 
    } 

    puts("Before rotation:"); 
    print_array(arr_sz, arr); 
    putchar('\n'); 

    rotate_array(arr_sz, arr); 
    puts("After rotation:"); 
    print_array(arr_sz, arr); 
    putchar('\n'); 

    return 0; 
} 

void print_array(size_t n, int a[n][n]) 
{ 
    for (size_t i = 0; i < n; i++) { 
     for (size_t j = 0; j < n; j++) { 
      printf("%5d", a[i][j]); 
     } 
     putchar('\n'); 
    } 
} 

void rotate_array(size_t n, int a[n][n]) 
{ 
    int rotated[n][n]; 
    for (size_t i = 0; i < n; i++) { 
     for (size_t j = 0; j < n; j++) { 
      rotated[i][j] = a[n - j - 1][i]; 
     } 
    } 
    memcpy(a, rotated, sizeof a[0][0] * n * n); 
} 

Before rotation: 
    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 

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