# Rotate a Matrix by 180 degree

Given a square matrix the task is that we turn it by 180 degrees in anti-clockwise direction without using any extra space.
Examples :

```Input :  1  2  3
4  5  6
7  8  9
Output : 9 8 7
6 5 4
3 2 1

Input :  1 2 3 4
5 6 7 8
9 0 1 2
3 4 5 6
Output : 6 5 4 3
2 1 0 9
8 7 6 5
4 3 2 1
```

Method : 1 (Only prints rotated matrix)
The solution of this problem is that to rotate a matrix by 180 degree we can easily follow that step

```Matrix =  a00 a01 a02
a10 a11 a12
a20 a21 a22

when we rotate it by 90 degree
then matrix is
Matrix = a02 a12 a22
a01 a11 a21
a00 a10 a20

when we rotate it by again 90
degree then matrix is
Matrix = a22 a21 a20
a12 a11 a10
a02 a01 a00
```

From the above illustration we get that simply to rotate the matrix by 180 degree then we will have to print given matrix in reverse manner .

## C++

 `// C++ program to rotate a matrix by 180 degrees ` `#include ` `#define N 3 ` `using` `namespace` `std; ` ` `  `// Function to Rotate the matrix by 180 degree ` `void` `rotateMatrix(``int` `mat[][N]) ` `{ ` `    ``// Simply print from last cell to first cell. ` `    ``for` `(``int` `i = N - 1; i >= 0; i--) { ` `        ``for` `(``int` `j = N - 1; j >= 0; j--) ` `            ``printf``(``"%d "``, mat[i][j]); ` ` `  `        ``printf``(````" "````); ` `    ``} ` `} ` ` `  `// Driven code ` `int` `main() ` `{ ` `    ``int` `mat[N][N] = { ` `        ``{ 1, 2, 3 }, ` `        ``{ 4, 5, 6 }, ` `        ``{ 7, 8, 9 } ` `    ``}; ` ` `  `    ``rotateMatrix(mat); ` `    ``return` `0; ` `} `

## Java

 `// Java program to rotate a ` `// matrix by 180 degrees ` `import` `java.util.*; ` ` `  `class` `GFG { ` `    ``static` `int` `N = ``3``; ` ` `  `    ``// Function to Rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `rotateMatrix(``int` `mat[][]) ` `    ``{ ` ` `  `        ``// Simply print from last ` `        ``// cell to first cell. ` `        ``for` `(``int` `i = N - ``1``; i >= ``0``; i--) { ` `            ``for` `(``int` `j = N - ``1``; j >= ``0``; j--) ` `                ``System.out.print(mat[i][j] + ``" "``); ` ` `  `            ``System.out.println(); ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] mat = { { ``1``, ``2``, ``3` `}, ` `                        ``{ ``4``, ``5``, ``6` `}, ` `                        ``{ ``7``, ``8``, ``9` `} }; ` ` `  `        ``rotateMatrix(mat); ` `    ``} ` `} ` ` `  `// This code is contributed by ChitraNayal `

## Python3

 `# Python3 program to  ` `# rotate a matrix by  ` `# 180 degrees ` `N ``=` `3``; ` ` `  `# Function to Rotate  ` `# the matrix by 180 degree ` `def` `rotateMatrix(mat): ` `     `  `    ``# Simply print from ` `    ``# last cell to first cell. ` `    ``i ``=` `N ``-` `1``;  ` `    ``while``(i >``=` `0``): ` `        ``j ``=` `N ``-` `1``; ` `        ``while``(j >``=` `0``): ` `            ``print``(mat[i][j], end ``=` `" "``); ` `            ``j ``=` `j ``-` `1``; ` `        ``print``(); ` `        ``i ``=` `i ``-` `1``; ` ` `  `# Driven code ` `mat ``=` `[[``1``, ``2``, ``3``], ` `       ``[ ``4``, ``5``, ``6` `], ` `       ``[ ``7``, ``8``, ``9` `]]; ` `rotateMatrix(mat); ` ` `  `# This code is contributed  ` `# by mits `

## C#

 `// C# program to rotate a ` `// matrix by 180 degrees ` `using` `System; ` ` `  `class` `GFG { ` `    ``static` `int` `N = 3; ` ` `  `    ``// Function to Rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `rotateMatrix(``int``[, ] mat) ` `    ``{ ` `        ``// Simply print from last ` `        ``// cell to first cell. ` `        ``for` `(``int` `i = N - 1; i >= 0; i--) { ` `            ``for` `(``int` `j = N - 1; j >= 0; j--) ` `                ``Console.Write(mat[i, j] + ``" "``); ` ` `  `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[, ] mat = { { 1, 2, 3 }, ` `                        ``{ 4, 5, 6 }, ` `                        ``{ 7, 8, 9 } }; ` ` `  `        ``rotateMatrix(mat); ` `    ``} ` `} ` ` `  `// This code is contributed by aj_36 `

## PHP

 `= 0; ``\$i``--)  ` `    ``{ ` `        ``for` `(``\$j` `= ``\$N` `- 1; ``\$j` `>= 0; ``\$j``--)  ` `            ``echo` `\$mat``[``\$i``][``\$j``], ``" "``; ` `         `  `    ``echo` ```" "````; ` `    ``} ` `} ` ` `  `// Driver Code ` `\$mat` `= ``array``(``array``(1, 2, 3), ` `             ``array``(4, 5, 6), ` `             ``array``(7, 8, 9)); ` ` `  `rotateMatrix(``\$mat``); ` ` `  `// This code is contributed by ajit ` `?> `

Output :

``` 9 8 7
6 5 4
3 2 1
```

Time complexity : O(N*N)
Auxiliary Space : O(1)

Method : 2(In-place rotation)
There are four steps :
1- Find transpose of matrix.
2- Reverse columns of the transpose.
3- Find transpose of matrix.
4- Reverse columns of the transpose

```Let the given matrix be
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

First we find transpose.
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

Then we reverse elements of every column.
4 8 12 16
3 7 11 15
2 6 10 14
1 5  9 13

then transpose again
4 3 2 1
8 7 6 5
12 11 10 9
16 15 14 13

Then we reverse elements of every column again
16 15 14 13
12 11 10 9
8 7 6 5
4 3 2 1
```

## C++

 `// C++ program for left rotation of matrix by 180 ` `#include ` `using` `namespace` `std; ` ` `  `#define R 4 ` `#define C 4 ` ` `  `// Function to rotate the matrix by 180 degree ` `void` `reverseColumns(``int` `arr[R][C]) ` `{ ` `    ``for` `(``int` `i = 0; i < C; i++) ` `        ``for` `(``int` `j = 0, k = C - 1; j < k; j++, k--) ` `            ``swap(arr[j][i], arr[k][i]); ` `} ` ` `  `// Function for transpose of matrix ` `void` `transpose(``int` `arr[R][C]) ` `{ ` `    ``for` `(``int` `i = 0; i < R; i++) ` `        ``for` `(``int` `j = i; j < C; j++) ` `            ``swap(arr[i][j], arr[j][i]); ` `} ` ` `  `// Function for display the matrix ` `void` `printMatrix(``int` `arr[R][C]) ` `{ ` `    ``for` `(``int` `i = 0; i < R; i++) { ` `        ``for` `(``int` `j = 0; j < C; j++) ` `            ``cout << arr[i][j] << ``" "``; ` `        ``cout << ````' '````; ` `    ``} ` `} ` ` `  `// Function to anticlockwise rotate matrix ` `// by 180 degree ` `void` `rotate180(``int` `arr[R][C]) ` `{ ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `} ` ` `  `// Driven code ` `int` `main() ` `{ ` `    ``int` `arr[R][C] = { { 1, 2, 3, 4 }, ` `                      ``{ 5, 6, 7, 8 }, ` `                      ``{ 9, 10, 11, 12 }, ` `                      ``{ 13, 14, 15, 16 } }; ` `    ``rotate180(arr); ` `    ``printMatrix(arr); ` `    ``return` `0; ` `} `

## Java

 `// Java program for left ` `// rotation of matrix by 180 ` `import` `java.util.*; ` ` `  `class` `GFG { ` `    ``static` `int` `R = ``4``, C = ``4``, t = ``0``; ` ` `  `    ``// Function to rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `reverseColumns(``int` `arr[][]) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < C; i++) { ` `            ``for` `(``int` `j = ``0``, k = C - ``1``; j < k; j++, k--) { ` `                ``t = arr[j][i]; ` `                ``arr[j][i] = arr[k][i]; ` `                ``arr[k][i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for transpose of matrix ` `    ``static` `void` `transpose(``int` `arr[][]) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < R; i++) { ` `            ``for` `(``int` `j = i; j < C; j++) { ` `                ``t = arr[i][j]; ` `                ``arr[i][j] = arr[j][i]; ` `                ``arr[j][i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for display the matrix ` `    ``static` `void` `printMatrix(``int` `arr[][]) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < R; i++) { ` `            ``for` `(``int` `j = ``0``; j < C; j++) ` `                ``System.out.print(arr[i][j] + ``" "``); ` `            ``System.out.println(); ` `        ``} ` `    ``} ` ` `  `    ``// Function to anticlockwise ` `    ``// rotate matrix by 180 degree ` `    ``static` `void` `rotate180(``int` `arr[][]) ` `    ``{ ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] arr = { { ``1``, ``2``, ``3``, ``4` `}, ` `                        ``{ ``5``, ``6``, ``7``, ``8` `}, ` `                        ``{ ``9``, ``10``, ``11``, ``12` `}, ` `                        ``{ ``13``, ``14``, ``15``, ``16` `} }; ` ` `  `        ``rotate180(arr); ` `        ``printMatrix(arr); ` `    ``} ` `} ` ` `  `// This code is contributed by ChitraNayal `

## C#

 `// C# program for left ` `// rotation of matrix by 180 ` `using` `System; ` ` `  `class` `GFG { ` `    ``static` `int` `R = 4, C = 4, t = 0; ` ` `  `    ``// Function to rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `reverseColumns(``int``[, ] arr) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < C; i++) { ` `            ``for` `(``int` `j = 0, k = C - 1; ` `                 ``j < k; j++, k--) { ` `                ``t = arr[j, i]; ` `                ``arr[j, i] = arr[k, i]; ` `                ``arr[k, i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for transpose of matrix ` `    ``static` `void` `transpose(``int``[, ] arr) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < R; i++) { ` `            ``for` `(``int` `j = i; j < C; j++) { ` `                ``t = arr[i, j]; ` `                ``arr[i, j] = arr[j, i]; ` `                ``arr[j, i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for display the matrix ` `    ``static` `void` `printMatrix(``int``[, ] arr) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < R; i++) { ` `            ``for` `(``int` `j = 0; j < C; j++) ` `                ``Console.Write(arr[i, j] + ``" "``); ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` ` `  `    ``// Function to anticlockwise ` `    ``// rotate matrix by 180 degree ` `    ``static` `void` `rotate180(``int``[, ] arr) ` `    ``{ ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[, ] arr = { { 1, 2, 3, 4 }, ` `                        ``{ 5, 6, 7, 8 }, ` `                        ``{ 9, 10, 11, 12 }, ` `                        ``{ 13, 14, 15, 16 } }; ` ` `  `        ``rotate180(arr); ` `        ``printMatrix(arr); ` `    ``} ` `} ` ` `  `// This code is contributed by ajit `

## Python 3

 `# Python 3 program for left rotation of matrix by 180 ` `  `  `R ``=` `4` `C ``=` `4` `  `  `# Function to rotate the matrix by 180 degree ` `def` `reverseColumns(arr): ` `    ``for` `i ``in` `range``(C): ` `        ``j ``=` `0` `        ``k ``=` `C``-``1` `        ``while` `j < k: ` `            ``t ``=` `arr[j][i] ` `            ``arr[j][i] ``=` `arr[k][i] ` `            ``arr[k][i] ``=` `t ` `            ``j ``+``=` `1` `            ``k ``-``=` `1` `             `  `# Function for transpose of matrix ` `def` `transpose(arr): ` `    ``for` `i ``in` `range``(R): ` `        ``for` `j ``in` `range``(i, C): ` `            ``t ``=` `arr[i][j] ` `            ``arr[i][j] ``=` `arr[j][i] ` `            ``arr[j][i] ``=` `t ` `  `  `# Function for display the matrix ` `def` `printMatrix(arr): ` `    ``for` `i ``in` `range``(R): ` `        ``for` `j ``in` `range``(C): ` `            ``print``(arr[i][j], end ``=` `" "``); ` `        ``print``(); ` `  `  `# Function to anticlockwise rotate matrix ` `# by 180 degree ` `def` `rotate180(arr): ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `  `  `# Driven code ` `arr ``=` `[ [ ``1``, ``2``, ``3``, ``4` `], ` `        ``[ ``5``, ``6``, ``7``, ``8` `], ` `        ``[``9``, ``10``, ``11``, ``12` `], ` `        ``[``13``, ``14``, ``15``, ``16` `] ]; ` `rotate180(arr); ` `printMatrix(arr); `

## PHP

 ` `

Output :

``` 16 15 14 13
12 11 10 9
8 7 6 5
4 3 2 1
```

Time complexity : O(R*C)
Auxiliary Space : O(1)