Array um 90 Grad drehen

Heinzi1991

Erfahrenes Mitglied
So da ich mein erstes Problem gelöst hab, kommt gleich einmal ein zweites!

Also ich hab jetzt 4 Arrays nebeneinander stehen und in der nächsten "Zeile" sind die gleichen vier, aber ich will diese Arrays um 90° Grad nach rechts drehen hab aber keinen Plan wie oder was ich genau machen soll!
Hier noch einmal der Code, wie weit ich schon bin:
Code:
#include <stdio.h>

int main()
{
	char array_1[4][4] = { {'-','-','-','-'},
                     {'-','o','-','-'},
                     {'o','o','o','-'},
                     {'-','-','-','-'}};

	char array_2[4][4] = { {'-','-','-','-'},
                     {'-','o','o','-'},
                     {'o','o','-','-'},
                     {'-','-','-','-'}};

	char array_3[4][4] = { {'-','-','-','-'},
                     {'-','o','-','-'},
                     {'-','o','-','-'},
                     {'-','o','o','-'}};

	char array_4[4][4] = { {'-','-','o','-'},
                     {'-','-','o','-'},
                     {'-','-','o','-'},
                     {'-','-','o','-'}};

    int counter = 0;
    int counter_1 = 0;


for(counter = 0; counter < 4; counter++) 
{
      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
		printf("%c ",array_1[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
         printf("%c ",array_2[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
         printf("%c ",array_3[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
         printf("%c ",array_4[counter][counter_1]);
      }
      printf("  ");

      printf("\n");
}

printf("\n");

for(counter = 0; counter < 4; counter++) 
{
      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
		printf("%c ",array_1[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
         printf("%c ",array_2[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
         printf("%c ",array_3[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++) 
      {
         printf("%c ",array_4[counter][counter_1]);
      }
      printf("  ");

      printf("\n");
}


return 0;
}
 

ibafluss

Erfahrenes Mitglied
Du meinst den Inhalt drehen oder?

Wenn ja, dann musst du nur die Arrayindizes vertausche:

C++:
#include <stdio.h>

int main()
{
    char array_1[4][4] = { {'-','-','-','-'},
                     {'-','o','-','-'},
                     {'o','o','o','-'},
                     {'-','-','-','-'}};

    char array_2[4][4] = { {'-','-','-','-'},
                     {'-','o','o','-'},
                     {'o','o','-','-'},
                     {'-','-','-','-'}};

    char array_3[4][4] = { {'-','-','-','-'},
                     {'-','o','-','-'},
                     {'-','o','-','-'},
                     {'-','o','o','-'}};

    char array_4[4][4] = { {'-','-','o','-'},
                     {'-','-','o','-'},
                     {'-','-','o','-'},
                     {'-','-','o','-'}};

    int counter = 0;
    int counter_1 = 0;


for(counter = 0; counter < 4; counter++)
{
      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
        printf("%c ",array_1[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
         printf("%c ",array_2[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
         printf("%c ",array_3[counter][counter_1]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
         printf("%c ",array_4[counter][counter_1]);
      }
      printf("  ");

      printf("\n");
}

printf("\n");

for(counter = 0; counter < 4; counter++)
{
      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
        printf("%c ",array_1[counter_1][counter]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
         printf("%c ",array_2[counter_1][counter]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
         printf("%c ",array_3[counter_1][counter]);
      }
      printf("  ");

      for(counter_1 = 0; counter_1 < 4; counter_1++)
      {
         printf("%c ",array_4[counter_1][counter]);
      }
      printf("  ");

      printf("\n");
}


return 0;
}
 

Heinzi1991

Erfahrenes Mitglied
Also ich will es um 90 Grad richtung rechts drehen! Deine Möglichkeit stimmt leider nicht so richtig!
Also so soll es am ende aussehen:

Ausgangswert ist das:

a11 a12 a13 a14
a21 a22 a23 a24
a31 a32 a33 a34
a41 a42 a43 a44

nach der drehung soll es so aussehen:

a41 a31 a21 a11
a42 a32 a22 a12
a43 a33 a23 a13
a44 a34 a24 a14
 

sheel

I love Asm
Schau dir doch mal dein Zielarray an, dann ists doch gar nicht so schwer.
Pseudocode: (rowcount ist Anzahl beim Quellarray von oben nach unten, col eben das Andere)
C++:
for(i= 0; i < array_colcount; i++)
{
    for(j = array_rowcount - 1; j >= 0; j--)
        array[j][i];
}
 

0664jester

Mitglied
Hallo,

Ich interessiere mich auch dafuer, aber bin erst c anfaenger und verstehe jetzt die loesung nicht ganz.
kann das jemand ausfuehrlicher erklaeren?



sry wegen den umlauten ich benutze eine us-tastatur.
 

sheel

I love Asm
Hi

Das obige Codestück ist nicht direkt zum Ausführen gedacht;
nur als Andeutung, wie die Schleifen sein sollten.
Deshalb kommts dir vielleicht komisch vor.

Was ein Array ist ist klar?

Kurz-kurz-Form:
C++:
int bla[4];
Mach ein Array aus 4 int´s, ansprechbar mit
bla[0], bla[1], bla[2] und bla[3]

Etwas wie
C++:
int bla[4][4];
erzeugt ein Array aus 4 mal 4 int´s (insgesamt also 16),
die man sich etwa als Tabelle angeordnet vorstellen kann
(nur fürs Vorstellen, im Computer anders)
Sowas:
Code:
bla[0][0]    bla[0][1]    bla[0][2]    bla[0][3]
bla[1][0]    bla[1][1]    bla[1][2]    bla[1][3]
bla[2][0]    bla[2][1]    bla[2][2]    bla[2][3]
bla[3][0]    bla[3][1]    bla[3][2]    bla[3][3]
Zum Zugreifen auf ein Arrayelement muss man hier, beim zweidimensionalen Array,
also zwei Zahlen angeben: Die wievielte Zeile und davon dann die wievielte Spalte.

Wenn man das ausgeben will beginnt man eben mit bla[0][0], bla[0][1]...neue Zeile, bla[1][0]...
Heinzi oben wollte aber eine andere Reihenfolge haben
Code:
bla[3][0]    bla[2][0]    bla[1][0]    bla[0][0]
bla[3][1]    bla[2][1]    bla[1][1]    bla[0][1]
bla[3][2]    bla[2][2]    bla[1][2]    bla[0][2]
bla[3][3]    bla[2][3]    bla[1][3]    bla[0][3]

Die ursprüngliche, normale Reihenfolge kann man so ausgeben:
C++:
for(i = 0; i < 4; i++)
{
    for(j = 0; j < 4; j++)
        printf("%d ", array[i][j]);
    printf("\n");
}
Also für die Zeile [0] die Spalten [0], [1], [2], [3], dann ein Zeilenwechsel
Dann für die Zeile 1...2...3 das Selbe, fertig.

Für die abgewandelte Version:
Wenn man oben hinschaut merkt man, dass etwas wie die "Zeilennummer"
diesmal am zweiten Index statt beim Ersten zu finden ist.
Oberste Zeile 0, darunter 1 usw.
Da kann man dann auch so eine Zeilenschleife von 0 bis 3 machen,
C++:
for(i = 0; i < 4; i++)
{
    //...
    printf("\n");
}
nur wird das i dann an zweiter Stelle bei den [][] eingetragen.

Und pro Zeile zählt man für den ersten Index 3-2-1-0.
C++:
for(i = 0; i < 4; i++)
{
    for(j = 3; i >= 0; i--)
        //...
    printf("\n");
}

Noch die Ausgabe:
C++:
for(i = 0; i < 4; i++)
{
    for(j = 3; i >= 0; i--)
        printf("%d ", array[j][i]);
    printf("\n");
}
Achtung, diesmal [j][i] statt [i][j]
Klar warum? :)

Fragen jeder Art natürlich willkommen :)
 

fredmania17

Grünschnabel
Hi, hätte diesbezüglich auch eine Frage.
Angenommen ich möchte das 2D array so lange weiterdrehen bis es wieder im ausgangszustand ist.
ich würde das array auf einem buffer zwischenspeichern und es dann wieder verwenden.
Jedoch funktioniert das nicht ganz und es wird immer wieder das ausgangsarray verwendet. Gibt es da einen bestimmten trick womit ich das ergebnis nach dem ersten drehen speichern und dann weiterdrehen kann?
lg :)
 

sheel

I love Asm
Naja, "Trick" würd ich das nicht nennen.

Um zuerst noch mal zur Ausgabe-Variante zurückzukommen:
Oben hab ich ja, verglichen zur "normalen" Reihenfolge,
praktisch nur [i] und [j] vertauscht und die j-Schleife geändert
(von "j=0;j<4;j++", also 0-1-2-3 zählen, zu "j=3;j>=0;j--", also 3-2-1-0)

Wenn man die j-Schleife normal lassen will könnte man statt [j] einfach [3-j] nehmen,
hat den gleichen Effekt. (Wenn man für j 0-1-2-3 einsetzt kommt ja 3-2-1-0 raus)

Also
C++:
for(i = 0; i < 4; i++)
{
    for(j = 0; i < 4; i++)
        printf("%d ", array[3-j][i]);
    printf("\n");
}
Jetzt hat man die Schleifen normal.
Wenn man ein zweites Array array2 hat kann man das
in der richtigen Reihenfolge durchlaufen und dabei die verdrehten Werte reinfüllen:
C++:
...
array2[i][j] = array[3-j][i];
...

Mehr brauchts nicht.
Wenn man das alles in einer Schleife viermal machen will sollte man
nach jedem Durchgang in der Schleife zuerst array2 unverändert in array zurückkopieren,
weil der nächste Schleifendurchgang ja wieder array als Quelle nimmt.
 

fredmania17

Grünschnabel
irgendwie blick ich nicht mehr ganz durch.
ich meine es ja verstanden zu haben, doch der code macht was er will.

Code:
for(i= 0; i < COLS; i++)
  {
    for(j = ROWS - 1; j >= 0; j--)
    {
      printf("%c", matrix[j][i]);
      buffer[i][j] = matrix[3-j][i];
    }
    printf("\n");
    atrix[i][j] = buffer[i][j];
  }

   for(i= 0; i < COLS; i++)
  {
    for(j = ROWS - 1; j >= 0; j--)
    {
   printf("%c", matrix[j][i]);
    }
    printf("\n");
  }

ich hab jetzt ja den buffer als zwischenspeicher verwendet, jedoch wird dieser nicht angenommen und als output bekommen ich beim 2. drehen dasselbe wie beim ersten.
wo könnte da der fehler liegen?