# mehr-dimensionale(n) Array(s) "drehen"



## Androbin (11. Mai 2014)

Hallo liebes Java-Forum, :toll:

Ich suche gerade nach einer Möglichkeit, einen mehr-dimensionalen Array zu "drehen" :rtfm:
In meinem Fall handelt es sich um einen 2-dimensionalen boolean-Array 
Was ich hier mit "drehen" meine, dürfte jedem klar sein :bloed:

Hier meine Frage *8*
Wie kann ich einen mehr-dimensionalen Array "drehen" :bahnhof:
Eigentlich muss es wie oben geschildert, nur ein 2-dimensionaler Array sein, ueh:
Aber es wäre natürlich besser, das ganze auch für Arrays mit mehr Dimensionen durchzusetzen opcorn:


----------



## Thallius (11. Mai 2014)

Androbin hat gesagt.:


> Hallo liebes Java-Forum, :toll:
> 
> Was ich hier mit "drehen" meine, dürfte jedem klar sein :bloed:



Ne, das ist es beim besten Willen nicht...

Gruß

Claus


----------



## MrXYF (11. Mai 2014)

Also, wenn ich das richtig verstanden habe, willst du eine Array so drehen:
1 2 3 4  ----- 1 1 1 1
1 2 3 4  ----\ 2 2 2 2
1 2 3 4  ----/ 3 3 3 3
1 2 3 4  ----- 4 4 4 4

Hab das grad ausprobiert, es sollte so funktionieren 

```
for(int x = 0; x < array.length; x++){
    	  for(int y = 0; y < array[0].length; y++){
    		  arrayNeu[x][y] = array[y][x];
    	  }  
    	  
      }
```

Viel Spaß damit


----------



## Androbin (12. Mai 2014)

: MrXYF *8*
Guter Ansatz, allerdings (würde) er den Array spiegeln :rtfm:
und zwar von links oben nach rechts unten. Trotzdem Danke !!! 
"würde" deshalb, da er bereits bearbeitete "Slots" überschreiben würde :bloed:
Allerdings lässt sich das leicht mit einem zweiten Array lösen :toll:


----------



## anti-held (12. Mai 2014)

Wenn diese Spiegelung keine Drehung ist,
wie ist das dann gemeint?


----------



## Androbin (12. Mai 2014)

Zur Verdeutlichung *8* :rtfm:

	Algorithmus von "MrXYF" *8* :bloed:

		1234 ==> 1595
		5678 ==> 2684
		9876 ==> 3773
		5432 ==> 4862

	Algorithmus, den ich suche *8* :toll:

		1234 ==> 5951
		5678 ==> 4862
		9876 ==> 3773
		5432 ==> 2684

[EDIT]
Wie ich gerade bemerkt habe, müsste ich eigentlich nur noch links/rechts spiegeln :idea:
[/EDIT]


----------



## Ruzmanz (12. Mai 2014)

Ich will euch von der Denkarbeit nicht abhalten ... euch ist schon klar, dass Google haufenweise Ergebnisse für "Java Array drehen" liefert?


----------



## lord239123 (13. Mai 2014)

Wichtig ist, dass die erste Spalte zur ersten Zeile wird usw. Danach muss man noch die Spalten spiegeln, wen nman nicht das gleiche Ergebnis haben will, wie in dem letzten Codebeispiel. 

Der Algorithmus könnte so aussehen:


```
public static int[][] drehen(int[][] array)
	{
		int[][] array2 = new int[array.length][array.length];
		
		//Zeilen richtig stellen
		for (int i = 0; i < array.length; i++) 
		{
			for (int j = 0; j < array.length; j++) 
			{
				array2[i][j] = array[j][i];
			}
		}
		
		//Spalten richtig stellen
		for (int i = 0; i < array2.length; i++) 
		{
			for (int j = 0; j < array2.length; j++) 
			{
				array[j][i] = array2[j][array.length-1-i];
			}
		}
		
		return array;
	}
```

Er funktioniert allerdings nur bei quadratischen Arrays.


----------



## Androbin (13. Mai 2014)

: lord239123 *8*


> Er funktioniert allerdings nur bei quadratischen Arrays.


Das lässt sich ändern *8*

```
public static Object[][] drehen( Object[][] array )
    {
        Object[][] array2 = new Object[ array[ 0 ].length ][ array.length ];
        
        //Zeilen richtig stellen
        for ( int i = 0; i < array.length; i++ ) 
        {
            for ( int j = 0; j < array[ 0 ].length; j++ ) 
            {
                array2[ i ][ j ] = array[ j ][ i ];
            }
        }
        
        //Spalten richtig stellen
        for ( int i = 0; i < array2.length; i++) 
        {
            for ( int j = 0; j < array2[ 0 ].length; j++ ) 
            {
                array[ j ][ i ] = array2[ j ][ array.length - 1 - i ];
            }
        }
        
        return array2;
    }
```


----------

