Open in App
Not now

# Flip the given Matrix along both diagonals in clockwise direction

• Difficulty Level : Hard
• Last Updated : 28 Feb, 2022

Given a matrix arr[][] of size M*N, where M is the number of rows and N is the number of columns. The task is to flip the matrix by both diagonals. Flipping the matrix means rotating all elements of the matrix in a clockwise direction, along the diagonal

Examples:

Input: arr[][] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }
Output: { {9, 8, 7}, {6, 5, 4}, {3, 2, 1} }
Explanation: Resultant matrix after flipping the matrix along the main diagonal: { {1, 4, 7}, {2, 5, 8}, {3, 6, 9} }
Resultant matrix after flipping the matrix along the second diagonal: { {9, 8, 7}, {6, 5, 4}, {3, 2, 1} }

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

Approach: The task can easily be solved using observations. One can observe that the resultant matrix would contain reversed rows in reverse order. Follow the below steps to solve the problem:

• Iterate over the rows of the matrix, and swap elements of the first row & last row in reverse order, and similarly second row & second last row, and so on.

Below is the implementation of the above code:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `const` `int` `m = 4, n = 4;`   `// Function to flip the matrix along ` `// both the diagonals` `void` `flip(``int` `matrix[m][n])` `{` `    ``int` `i, j, temp;` `      `  `      ``// Swapping elements` `    ``for` `(i = 0; i < m / 2; i++) {` `        ``for` `(j = 0; j < n; j++) {` `            ``temp = matrix[i][j];` `            ``matrix[i][j] = matrix[m - 1 - i][n - 1 - j];` `            ``matrix[m - 1 - i][n - 1 - j] = temp;` `        ``}` `    ``}` `}`   `// Function to print the matrix` `void` `show(``int` `matrix[m][n])` `{` `    ``int` `i, j;` `    ``for` `(i = 0; i < m; i++) {` `        ``for` `(j = 0; j < n; j++) {` `            ``cout << matrix[i][j] << ``"  "``;` `        ``}` `        ``cout << endl;` `    ``}` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `matrix[4][4] = { { 1, 2, 3, 4 },` `                         ``{ 5, 6, 7, 8 },` `                         ``{ 9, 10, 11, 12 },` `                         ``{ 13, 14, 15, 16 } };`   `    ``flip(matrix);` `    ``show(matrix);` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG{`   `static` `int` `m = ``4``, n = ``4``;`   `// Function to flip the matrix along ` `// both the diagonals` `static` `void` `flip(``int` `matrix[][])` `{` `    ``int` `i, j, temp;` `      `  `      ``// Swapping elements` `    ``for` `(i = ``0``; i < m / ``2``; i++) {` `        ``for` `(j = ``0``; j < n; j++) {` `            ``temp = matrix[i][j];` `            ``matrix[i][j] = matrix[m - ``1` `- i][n - ``1` `- j];` `            ``matrix[m - ``1` `- i][n - ``1` `- j] = temp;` `        ``}` `    ``}` `}`   `// Function to print the matrix` `static` `void` `show(``int` `matrix[][])` `{` `    ``int` `i, j;` `    ``for` `(i = ``0``; i < m; i++) {` `        ``for` `(j = ``0``; j < n; j++) {` `            ``System.out.print(matrix[i][j]+ ``"  "``);` `        ``}` `        ``System.out.println();` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{`   `    ``int` `matrix[][] = { { ``1``, ``2``, ``3``, ``4` `},` `                         ``{ ``5``, ``6``, ``7``, ``8` `},` `                         ``{ ``9``, ``10``, ``11``, ``12` `},` `                         ``{ ``13``, ``14``, ``15``, ``16` `} };` `    ``flip(matrix);` `    ``show(matrix);` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach` `m ``=` `4` `n ``=` `4`   `# Function to flip the matrix along` `# both the diagonals` `def` `flip(matrix):` `    `  `    ``i ``=` `None` `    ``j ``=` `None` `    ``temp ``=` `None`   `    ``# Swapping elements` `    ``for` `i ``in` `range``(m ``/``/` `2``):` `        ``for` `j ``in` `range``(n):` `            ``temp ``=` `matrix[i][j]` `            ``matrix[i][j] ``=` `matrix[m ``-` `1` `-` `i][n ``-` `1` `-` `j]` `            ``matrix[m ``-` `1` `-` `i][n ``-` `1` `-` `j] ``=` `temp`   `# Function to print the matrix` `def` `show(matrix):` `    `  `    ``i ``=` `None` `    ``j ``=` `None` `    ``for` `i ``in` `range``(m):` `        ``for` `j ``in` `range``(n):` `            ``print``(matrix[i][j], end ``=` `"  "``)` `            `  `        ``print``("")`   `# Driver Code` `matrix ``=` `[ [ ``1``, ``2``, ``3``, ``4` `],` `           ``[ ``5``, ``6``, ``7``, ``8` `],` `           ``[ ``9``, ``10``, ``11``, ``12` `],` `           ``[ ``13``, ``14``, ``15``, ``16` `] ]`   `flip(matrix)` `show(matrix)`   `# This code is contributed by gfgking`

## C#

 `// C# program for the above approach` `using` `System;` `class` `GFG` `{` `  ``const` `int` `m = 4, n = 4;`   `  ``// Function to flip the matrix along` `  ``// both the diagonals` `  ``static` `void` `flip(``int``[, ] matrix)` `  ``{` `    ``int` `i, j, temp;`   `    ``// Swapping elements` `    ``for` `(i = 0; i < m / 2; i++) {` `      ``for` `(j = 0; j < n; j++) {` `        ``temp = matrix[i, j];` `        ``matrix[i, j] = matrix[m - 1 - i, n - 1 - j];` `        ``matrix[m - 1 - i, n - 1 - j] = temp;` `      ``}` `    ``}` `  ``}`   `  ``// Function to print the matrix` `  ``static` `void` `show(``int``[, ] matrix)` `  ``{` `    ``int` `i, j;` `    ``for` `(i = 0; i < m; i++) {` `      ``for` `(j = 0; j < n; j++) {` `        ``Console.Write(matrix[i, j] + ``"  "``);` `      ``}` `      ``Console.WriteLine();` `    ``}` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main()` `  ``{`   `    ``int``[, ] matrix = { { 1, 2, 3, 4 },` `                      ``{ 5, 6, 7, 8 },` `                      ``{ 9, 10, 11, 12 },` `                      ``{ 13, 14, 15, 16 } };`   `    ``flip(matrix);` `    ``show(matrix);` `  ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output

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

Time Complexity: O(M*N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles