# Rotating a 2D Array by 90 Degrees (Java)

The problem is: Implement a function that takes a squareÂ 2D array (#Â columns = #Â rows = n) and rotates it by 90 degrees. Do not create a separate 2D array for the rotation, it rotates in the 2D array.

Example:

```int a1[][] = {{1, 2, 3},
{4, 5, 6},
{7, 8, 9}};
Â // rotate(a1, 3) should return:
// [[7, 4, 1],
// [8, 5, 2],
// [9, 6, 3]]```

Example:

```Â  int a2[][] = {{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12},
{13, 14, 15, 16}};
Â // rotate(a2, 4) should return:
// [[13, 9, 5, 1],
// [14, 10, 6, 2],
// [15, 11, 7, 3],
// [16, 12, 8, 4]]```

My method rotates the matrix in the same array and does not need an additional matrix to store temp data. It is different from many other solutions online.

a. The Swap:

Each element in the rotation is changing position with 3 other elements in the 2D array: a->b, b->c, c->d, d->a

``` [?, a, ?, ?]
[?, ?, ?, b]
[d, ?, ?, ?]
[?, ?, c, ?]```

Observation 1: If a={i,j}, then b={j,n-1-i}, c={n-1-i, n-1-j},d={n-1-j,i}

b. Row i:

Each rotation happens in a “ring” (example, a1, a2, a2,Â  b1, b2, b3….d2, d2), only the first `n-1` elements in the first row needs to be swapped. For example, in this 4 x 4 matrix, I only need to swap a1, a2, a3, with b1, b2, b3. Then swap b1, b2, b3 with c1, c2, c3. and this continues.

``` [a1, a2, a3, b1]
[d3, ??, ??, b2]
[d2, ??, ??, b3]
[d1, c3, c2, c1]```

Observation 2: At each row i, only swap the first `n-1` elements. i changes from `0` to `n-2`, So the outer loop should be for (int i=0; i < n-1; i++):

c. Column j:

Swapping from the outside ring (1’s) to the inner rings (2’s), the number of iteration decrements by 2. For example, in this 4 x 4 Matrix, the outside ring (1’s) has a length of 4, the inner ring (2’s) has a length of 2.

``` [1, 1, 1, 1]
[1, 2, 2, 1]
[1, 2, 2, 1]
[1, 1, 1, 1]```

Observation 3: At ith ring, the column number j starts at ith element and ends at n-1-i th elements. j changes from `i` to `n-2-i` So the inner loop is for (int j=i; j<n-1-i; j++)

Put everything together:

``` public static int[][] rotate(int[][] a, int n) {

for (int i=0; i< n-1; i++){  <--- outer loop
for (int j=i; j<n-1-i; j++){   <--- inner loop
int temp = a[i][j];    <--- do the swapping
a[i][j] = a[n-1-j][i];
a[n-1-j][i] = a[n-1-i][n-1-j];
a[n-1-i][n-1-j] = a[j][n-1-i];
a[j][n-1-i] = temp;
}
}
return a;
}
}```