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