# Mirror of matrix across diagonal

Given a 2-D array of order N x N, print a matrix which is mirror of given tree across diagonal. We need to print the result in a way, swap the values of the triangle above the diagonal with the values of the triangle below it like a mirror image swap. Print the 2-D array obtained in matrix layout.

Examples:

```Input : int mat[][] = {{1 2 4 }
{5 9 0}
{ 3 1 7}}
Output :  1 5 3
2 9 1
4 0 7

Input : mat[][] = {{1  2  3  4 }
{5  6  7  8 }
{9  10 11 12}
{13 14 15 16} }
Output : 1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Simple solution of this problem consumes extra space, we traverse all right diagonal (right-to-left) one-by-one. During the traversal of diagonal, first we push all the elements into the stack and after we traverse it again and replace every element of diagonal with the stack element.

Below is the implementation of above idea.

 `// Simple CPP program to find mirror of ` `// matrix across diagonal. ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `MAX = 100; ` ` `  `void` `imageSwap(``int` `mat[][MAX], ``int` `n) ` `{ ` `    ``// for diagonal which start from at  ` `    ``// first row of matrix ` `    ``int` `row = 0; ` ` `  `    ``// traverse all top right diagonal ` `    ``for` `(``int` `j = 0; j < n; j++) { ` ` `  `        ``// here we use stack for reversing ` `        ``// the element of diagonal ` `        ``stack<``int``> s; ` `        ``int` `i = row, k = j; ` `        ``while` `(i < n && k >= 0)  ` `            ``s.push(mat[i++][k--]); ` `         `  `        ``// push all element back to matrix  ` `        ``// in reverse order ` `        ``i = row, k = j; ` `        ``while` `(i < n && k >= 0) { ` `            ``mat[i++][k--] = s.top(); ` `            ``s.pop(); ` `        ``} ` `    ``} ` ` `  `    ``// do the same process for all the ` `    ``// diagonal which start from last ` `    ``// column ` `    ``int` `column = n - 1; ` `    ``for` `(``int` `j = 1; j < n; j++) { ` ` `  `        ``// here we use stack for reversing  ` `        ``// the elements of diagonal ` `        ``stack<``int``> s; ` `        ``int` `i = j, k = column; ` `        ``while` `(i < n && k >= 0)  ` `            ``s.push(mat[i++][k--]); ` `         `  `        ``// push all element back to matrix  ` `        ``// in reverse order ` `        ``i = j; ` `        ``k = column; ` `        ``while` `(i < n && k >= 0) { ` `            ``mat[i++][k--] = s.top(); ` `            ``s.pop(); ` `        ``} ` `    ``} ` `} ` ` `  `// Utility function to print a matrix ` `void` `printMatrix(``int` `mat[][MAX], ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``cout << mat[i][j] << ``" "``; ` `        ``cout << endl; ` `    ``} ` `} ` ` `  `// driver program to test above function ` `int` `main() ` `{ ` `    ``int` `mat[][MAX] = { { 1, 2, 3, 4 }, ` `                     ``{ 5, 6, 7, 8 }, ` `                     ``{ 9, 10, 11, 12 }, ` `                     ``{ 13, 14, 15, 16 } }; ` `    ``int` `n = 4; ` `    ``imageSwap(mat, n); ` `    ``printMatrix(mat, n); ` `    ``return` `0; ` `} `

 `// Simple Java program to find mirror of ` `// matrix across diagonal. ` ` `  `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``static` `int` `MAX = ``100``; ` ` `  `    ``static` `void` `imageSwap(``int` `mat[][], ``int` `n)  ` `    ``{ ` `        ``// for diagonal which start from at  ` `        ``// first row of matrix ` `        ``int` `row = ``0``; ` ` `  `        ``// traverse all top right diagonal ` `        ``for` `(``int` `j = ``0``; j < n; j++)  ` `        ``{ ` ` `  `            ``// here we use stack for reversing ` `            ``// the element of diagonal ` `            ``Stack s = ``new` `Stack<>(); ` `            ``int` `i = row, k = j; ` `            ``while` `(i < n && k >= ``0``) ` `            ``{ ` `                ``s.push(mat[i++][k--]); ` `            ``} ` ` `  `            ``// push all element back to matrix  ` `            ``// in reverse order ` `            ``i = row; ` `            ``k = j; ` `            ``while` `(i < n && k >= ``0``) ` `            ``{ ` `                ``mat[i++][k--] = s.peek(); ` `                ``s.pop(); ` `            ``} ` `        ``} ` ` `  `        ``// do the same process for all the ` `        ``// diagonal which start from last ` `        ``// column ` `        ``int` `column = n - ``1``; ` `        ``for` `(``int` `j = ``1``; j < n; j++) ` `        ``{ ` ` `  `            ``// here we use stack for reversing  ` `            ``// the elements of diagonal ` `            ``Stack s = ``new` `Stack<>(); ` `            ``int` `i = j, k = column; ` `            ``while` `(i < n && k >= ``0``) ` `            ``{ ` `                ``s.push(mat[i++][k--]); ` `            ``} ` ` `  `            ``// push all element back to matrix  ` `            ``// in reverse order ` `            ``i = j; ` `            ``k = column; ` `            ``while` `(i < n && k >= ``0``) ` `            ``{ ` `                ``mat[i++][k--] = s.peek(); ` `                ``s.pop(); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Utility function to print a matrix ` `    ``static` `void` `printMatrix(``int` `mat[][], ``int` `n)  ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``{ ` `                ``System.out.print(mat[i][j] + ``" "``); ` `            ``} ` `            ``System.out.println(``""``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver program to test above function ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` ` `  `        ``int` `mat[][] = {{``1``, ``2``, ``3``, ``4``}, ` `        ``{``5``, ``6``, ``7``, ``8``}, ` `        ``{``9``, ``10``, ``11``, ``12``}, ` `        ``{``13``, ``14``, ``15``, ``16``}}; ` `        ``int` `n = ``4``; ` `        ``imageSwap(mat, n); ` `        ``printMatrix(mat, n); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

 `# Simple Python3 program to find mirror of ` `# matrix across diagonal. ` `MAX` `=` `100` ` `  `def` `imageSwap(mat, n): ` `     `  `    ``# for diagonal which start from at  ` `    ``# first row of matrix ` `    ``row ``=` `0` `     `  `    ``# traverse all top right diagonal ` `    ``for` `j ``in` `range``(n): ` `         `  `        ``# here we use stack for reversing ` `        ``# the element of diagonal ` `        ``s ``=` `[] ` `        ``i ``=` `row ` `        ``k ``=` `j ` `        ``while` `(i < n ``and` `k >``=` `0``): ` `            ``s.append(mat[i][k]) ` `            ``i ``+``=` `1` `            ``k ``-``=` `1` `             `  `        ``# push all element back to matrix  ` `        ``# in reverse order ` `        ``i ``=` `row ` `        ``k ``=` `j ` `        ``while` `(i < n ``and` `k >``=` `0``): ` `            ``mat[i][k] ``=` `s[``-``1``] ` `            ``k ``-``=` `1` `            ``i ``+``=` `1` `            ``s.pop() ` `             `  `    ``# do the same process for all the ` `    ``# diagonal which start from last ` `    ``# column ` `    ``column ``=` `n ``-` `1` `    ``for` `j ``in` `range``(``1``, n):  ` `         `  `        ``# here we use stack for reversing  ` `        ``# the elements of diagonal ` `        ``s ``=` `[] ` `        ``i ``=` `j ` `        ``k ``=` `column ` `        ``while` `(i < n ``and` `k >``=` `0``): ` `            ``s.append(mat[i][k]) ` `            ``i ``+``=` `1` `            ``k ``-``=` `1` `             `  `        ``# push all element back to matrix  ` `        ``# in reverse order ` `        ``i ``=` `j ` `        ``k ``=` `column ` `        ``while` `(i < n ``and` `k >``=` `0``): ` `            ``mat[i][k] ``=` `s[``-``1``] ` `            ``i ``+``=` `1` `            ``k ``-``=` `1` `            ``s.pop() ` ` `  `# Utility function to pra matrix ` `def` `printMatrix(mat, n): ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n): ` `            ``print``(mat[i][j], end``=``" "``) ` `        ``print``() ` `         `  `# Driver code ` `mat ``=` `[[``1``, ``2``, ``3``, ``4``],[``5``, ``6``, ``7``, ``8``], ` `        ``[``9``, ``10``, ``11``, ``12``],[``13``, ``14``, ``15``, ``16``]] ` `n ``=` `4` `imageSwap(mat, n) ` `printMatrix(mat, n) ` ` `  `# This code is contributed by shubhamsingh10 `

 `// Simple C# program to find mirror of ` `// matrix across diagonal. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``static` `int` `MAX = 100; ` ` `  `    ``static` `void` `imageSwap(``int` `[,]mat, ``int` `n)  ` `    ``{ ` `        ``// for diagonal which start from at  ` `        ``// first row of matrix ` `        ``int` `row = 0; ` ` `  `        ``// traverse all top right diagonal ` `        ``for` `(``int` `j = 0; j < n; j++)  ` `        ``{ ` ` `  `            ``// here we use stack for reversing ` `            ``// the element of diagonal ` `            ``Stack<``int``> s = ``new` `Stack<``int``>(); ` `            ``int` `i = row, k = j; ` `            ``while` `(i < n && k >= 0) ` `            ``{ ` `                ``s.Push(mat[i++,k--]); ` `            ``} ` ` `  `            ``// push all element back to matrix  ` `            ``// in reverse order ` `            ``i = row; ` `            ``k = j; ` `            ``while` `(i < n && k >= 0) ` `            ``{ ` `                ``mat[i++,k--] = s.Peek(); ` `                ``s.Pop(); ` `            ``} ` `        ``} ` ` `  `        ``// do the same process for all the ` `        ``// diagonal which start from last ` `        ``// column ` `        ``int` `column = n - 1; ` `        ``for` `(``int` `j = 1; j < n; j++) ` `        ``{ ` ` `  `            ``// here we use stack for reversing  ` `            ``// the elements of diagonal ` `            ``Stack<``int``> s = ``new` `Stack<``int``>(); ` `            ``int` `i = j, k = column; ` `            ``while` `(i < n && k >= 0) ` `            ``{ ` `                ``s.Push(mat[i++,k--]); ` `            ``} ` ` `  `            ``// push all element back to matrix  ` `            ``// in reverse order ` `            ``i = j; ` `            ``k = column; ` `            ``while` `(i < n && k >= 0) ` `            ``{ ` `                ``mat[i++,k--] = s.Peek(); ` `                ``s.Pop(); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Utility function to print a matrix ` `    ``static` `void` `printMatrix(``int` `[,]mat, ``int` `n)  ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = 0; j < n; j++) ` `            ``{ ` `                ``Console.Write(mat[i,j] + ``" "``); ` `            ``} ` `            ``Console.WriteLine(``""``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` ` `  `        ``int` `[,]mat = {{1, 2, 3, 4}, ` `                    ``{5, 6, 7, 8}, ` `                    ``{9, 10, 11, 12}, ` `                    ``{13, 14, 15, 16}}; ` `        ``int` `n = 4; ` `        ``imageSwap(mat, n); ` `        ``printMatrix(mat, n); ` `    ``} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

Output:

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

Time complexity : O(n*n)

Efficient solution of this problem is that if we observe a output matrix than we notice that we just have to swap (mat[i][j] mat[j][i]).
Below is the implementation of above idea.\

 `// Efficient CPP program to find mirror of ` `// matrix across diagonal. ` `#include ` `using` `namespace` `std; ` ` `  `const` `int` `MAX = 100; ` ` `  `void` `imageSwap(``int` `mat[][MAX], ``int` `n) ` `{ ` `    ``// traverse a matrix and swap  ` `    ``// mat[i][j] with mat[j][i] ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = 0; j <= i; j++)  ` `            ``mat[i][j] = mat[i][j] + mat[j][i] -  ` `                       ``(mat[j][i] = mat[i][j]);        ` `} ` ` `  `// Utility function to print a matrix ` `void` `printMatrix(``int` `mat[][MAX], ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``for` `(``int` `j = 0; j < n; j++) ` `            ``cout << mat[i][j] << ``" "``; ` `        ``cout << endl; ` `    ``} ` `} ` ` `  `// driver program to test above function ` `int` `main() ` `{ ` `    ``int` `mat[][MAX] = { { 1, 2, 3, 4 }, ` `                     ``{ 5, 6, 7, 8 }, ` `                     ``{ 9, 10, 11, 12 }, ` `                     ``{ 13, 14, 15, 16 } }; ` `    ``int` `n = 4; ` `    ``imageSwap(mat, n); ` `    ``printMatrix(mat, n); ` `    ``return` `0; ` `} `

 `// Efficient Java program to find mirror of ` `// matrix across diagonal. ` `import` `java.io.*; ` ` `  `class` `GFG { ` `     `  `    ``static` `int` `MAX = ``100``; ` `     `  `    ``static` `void` `imageSwap(``int` `mat[][], ``int` `n) ` `    ``{ ` `         `  `        ``// traverse a matrix and swap  ` `        ``// mat[i][j] with mat[j][i] ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``for` `(``int` `j = ``0``; j <= i; j++)  ` `                ``mat[i][j] = mat[i][j] + mat[j][i] ` `                       ``- (mat[j][i] = mat[i][j]);      ` `    ``} ` `     `  `    ``// Utility function to print a matrix ` `    ``static` `void` `printMatrix(``int` `mat[][], ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `                ``System.out.print( mat[i][j] + ``" "``); ` `            ``System.out.println(); ` `        ``} ` `    ``} ` `     `  `    ``// driver program to test above function ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `mat[][] = { { ``1``, ``2``, ``3``, ``4` `}, ` `                        ``{ ``5``, ``6``, ``7``, ``8` `}, ` `                        ``{ ``9``, ``10``, ``11``, ``12` `}, ` `                        ``{ ``13``, ``14``, ``15``, ``16` `} }; ` `        ``int` `n = ``4``; ` `        ``imageSwap(mat, n); ` `        ``printMatrix(mat, n); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

 `# Efficient Python3 program to find mirror of ` `# matrix across diagonal. ` `from` `builtins ``import` `range` `MAX` `=` `100``; ` ` `  `def` `imageSwap(mat, n): ` ` `  `    ``# traverse a matrix and swap ` `    ``# mat[i][j] with mat[j][i] ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(i ``+` `1``): ` `            ``t ``=` `mat[i][j]; ` `            ``mat[i][j] ``=` `mat[j][i] ` `            ``mat[j][i] ``=` `t ` ` `  `# Utility function to pra matrix ` `def` `printMatrix(mat, n): ` `    ``for` `i ``in` `range``(n): ` `        ``for` `j ``in` `range``(n): ` `            ``print``(mat[i][j], end``=``" "``); ` `        ``print``(); ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``mat ``=` `[``1``, ``2``, ``3``, ``4``], \ ` `        ``[``5``, ``6``, ``7``, ``8``], \ ` `        ``[``9``, ``10``, ``11``, ``12``], \ ` `        ``[``13``, ``14``, ``15``, ``16``]; ` `    ``n ``=` `4``; ` `    ``imageSwap(mat, n); ` `    ``printMatrix(mat, n); ` ` `  `# This code is contributed by Rajput-Ji `

 `// Efficient C# program to find mirror of ` `// matrix across diagonal. ` `using` `System; ` `class` `GFG { ` `     `  `    ``//static int MAX = 100; ` `     `  `    ``static` `void` `imageSwap(``int` `[,]mat, ``int` `n) ` `    ``{ ` `         `  `        ``// traverse a matrix and swap  ` `        ``// mat[i][j] with mat[j][i] ` `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``for` `(``int` `j = 0; j <= i; j++)  ` `                ``mat[i,j] = mat[i,j] + mat[j,i] ` `                    ``- (mat[j,i] = mat[i,j]);      ` `    ``} ` `     `  `    ``// Utility function to print a matrix ` `    ``static` `void` `printMatrix(``int` `[,]mat, ``int` `n) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``for` `(``int` `j = 0; j < n; j++) ` `                ``Console.Write( mat[i,j] + ``" "``); ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` `     `  `    ``// driver program to test above function ` `    ``public` `static` `void` `Main ()  ` `    ``{ ` `        ``int` `[,]mat = { { 1, 2, 3, 4 }, ` `                        ``{ 5, 6, 7, 8 }, ` `                        ``{ 9, 10, 11, 12 }, ` `                        ``{ 13, 14, 15, 16 } }; ` `        ``int` `n = 4; ` `        ``imageSwap(mat, n); ` `        ``printMatrix(mat, n); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

 ` `

Output:

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

Time complexity : O(n*n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :