# Inplace rotate matrix 90 degree

Posted: 30 Oct, 2020

Difficulty: Easy

#### You are given a square matrix of non-negative integers of size 'N x N'. Your task is to rotate that array by 90 degrees in an anti-clockwise direction without using any extra space.

#### For example:

```
For given 2D array :
[ [ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ] ]
After 90 degree rotation in anti clockwise direction, it will become:
[ [ 3, 6, 9 ],
[ 2, 5, 8 ],
[ 1, 4, 7 ] ]
```

##### Input Format :

```
The first line of input contains an integer 'T' representing the number of the test case. Then the test case follows.
The first line of each test case contains an integer 'N' representing the size of the square matrix ARR.
Each of the next 'N' lines contains 'N' space-separated integers representing the elements of the matrix 'ARR'.
```

##### Output Format:

```
For each test case, return the rotated matrix.
```

##### Note:

```
You do not need to print anything; it has already been taken care of. Just implement the given function.
```

##### Constraints:

```
1 ≤ T ≤ 50
1 ≤ N ≤ 100
1 ≤ ARR[i][j] ≤ 10^9
Time Limit: 1 sec
```

Approach 1

- There are N/2 cycles in a matrix of size ‘N’.
- We traverse in the matrix from the outermost cycle, i.e. (0,0) to innermost cycle i.e. ((N/2)-1, (N/2)-1).
- For each cycle, we’ll swap the elements of the matrix in a group of four elements i.e. for each ‘i’ <= ‘j’ < ‘N-i-1’ for each 0 <= ‘i’ <= ‘(N/2)-1’ we swap:
- ‘ARR[i] [j]’ with ‘ARR[j, N-1-i]’
- ‘ARR[j, N-1-i]’ with ‘ARR[N-1-i, N-1-j]’
- ‘ARR[N-1-i, N-1-j]’ with ‘ARR[N-1-j,i]’
- ‘ARR[N-1-j,i]’ with ‘ARR[i][j]’

- At the end of these loops, we’ll get rotated matrix.
- Print the matrix.

Approach 2

- To solve the problem, there have to perform two tasks.
- Finding the transpose
- Reversing the columns

- For finding the transpose of the matrix we swap ‘A’RR[i][j]' with ‘ARR[j][i]’ for each 0 <= ‘i’ < ‘N’ and ‘i’ <= ‘j’ < ‘N’ i.e. we swap elements across the principal diagonal of the matrix.
- Then we reverse the columns by swapping ‘ARR[j][i]’ to ‘ARR[k][i]' for each 0 <= ‘i’ < ‘N’ representing the columns and 0 <= ‘j’, ‘k’ < ‘N’ where,
- 'j' is incremented from 0 to the point where ‘j’ >= ‘k’.
- ‘k’ is decremented from ‘N-1’ to the point where ‘k’ <= 'j'.

SIMILAR PROBLEMS

# Count of paths

Posted: 7 Jul, 2021

Difficulty: Hard

# Similar Strings

Posted: 7 Jul, 2021

Difficulty: Ninja

# Palindromes And Indexes

Posted: 7 Jul, 2021

Difficulty: Moderate

# Ceiling in a sorted array

Posted: 8 Jul, 2021

Difficulty: Moderate

# Game of 3

Posted: 11 Jul, 2021

Difficulty: Easy