GFG App
Open App
Browser
Continue

# Rotate all Matrix elements except the diagonal K times by 90 degrees in clockwise direction

Given a square matrix mat[][] of dimension N and an integer K, the task is to rotate the matrix by 90 degrees K times without changing the position of the diagonal elements.

Examples:

Input: mat[][] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25}}, K = 1
Output:
1 16 11 6 5
22 7 12 9 2
23 18 13 8 3
24 17 14 19 4
21 20 15 10 25

Input: mat[][] = {{10, 11}, {12, 13}}, K = 2
Output:
10 11
12 13

Approach: The given problem can be solved by using the idea discussed in this article and the fact that the matrix restores after performing clockwise rotation 4 times. Follow the below steps to solve the given problem:

• Update the value of K as K % 4.
• Iterate until K is a positive and perform the following steps:
• Traverse the matrix, for i over the range [0, N / 2) and j over the range[0, N – i – 1) and perform the following steps:
• If the value of i != j and (i + j) != (N – 1), then perform the following steps:
• Store the value of mat[i][j] in a temporary variable temp.
• Update the value of mat[i][j] as mat[N – 1 – j][i].
• Update the value of mat[N – 1 – j][i] as mat[N – 1 -i][N – 1 – j].
• Update the value of mat[N – 1  – i][N – 1 – j] as mat[j][N – 1 – i].
• Update the value of mat[j][N – 1 – i] as temp.
• After completing the above steps, print the updated matrix obtained.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to print the matrix` `void` `print(vector >& mat)` `{` `    ``// Iterate over the rows` `    ``for` `(``int` `i = 0; i < mat.size(); i++) {`   `        ``// Iterate over the columns` `        ``for` `(``int` `j = 0; j < mat[0].size(); j++)`   `            ``// Print the value` `            ``cout << setw(3) << mat[i][j];` `        ``cout << ``"\n"``;` `    ``}` `}`   `// Function to perform the swapping of` `// matrix elements in clockwise manner` `void` `performSwap(vector >& mat,` `                 ``int` `i, ``int` `j)` `{` `    ``int` `N = mat.size();`   `    ``// Stores the last row` `    ``int` `ei = N - 1 - i;`   `    ``// Stores the last column` `    ``int` `ej = N - 1 - j;`   `    ``// Perform the swaps` `    ``int` `temp = mat[i][j];` `    ``mat[i][j] = mat[ej][i];` `    ``mat[ej][i] = mat[ei][ej];` `    ``mat[ei][ej] = mat[j][ei];` `    ``mat[j][ei] = temp;` `}`   `// Function to rotate non - diagonal` `// elements of the matrix K times in` `// clockwise direction` `void` `rotate(vector >& mat,` `            ``int` `N, ``int` `K)` `{` `    ``// Update K to K % 4` `    ``K = K % 4;`   `    ``// Iterate until K is positive` `    ``while` `(K--) {`   `        ``// Iterate each up to N/2-th row` `        ``for` `(``int` `i = 0; i < N / 2; i++) {`   `            ``// Iterate each column` `            ``// from i to N - i - 1` `            ``for` `(``int` `j = i;` `                 ``j < N - i - 1; j++) {`   `                ``// Check if the element` `                ``// at i, j is not a` `                ``// diagonal element` `                ``if` `(i != j` `                    ``&& (i + j) != N - 1) {`   `                    ``// Perform the swapping` `                    ``performSwap(mat, i, j);` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Print the matrix` `    ``print(mat);` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `K = 5;` `    ``vector > mat = {` `        ``{ 1, 2, 3, 4 },` `        ``{ 6, 7, 8, 9 },` `        ``{ 11, 12, 13, 14 },` `        ``{ 16, 17, 18, 19 },` `    ``};` `    ``int` `N = mat.size();` `    ``rotate(mat, N, K);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `public` `class` `GFG {`   `    ``// Function to print the matrix` `    ``static` `void` `print(``int` `mat[][])` `    ``{` `        ``// Iterate over the rows` `        ``for` `(``int` `i = ``0``; i < mat.length; i++) {`   `            ``// Iterate over the columns` `            ``for` `(``int` `j = ``0``; j < mat[``0``].length; j++)`   `                ``// Print the value` `                ``System.out.print(mat[i][j] + ``" "``);` `          `  `            ``System.out.println();` `        ``}` `    ``}`   `    ``// Function to perform the swapping of` `    ``// matrix elements in clockwise manner` `    ``static` `void` `performSwap(``int` `mat[][], ``int` `i, ``int` `j)` `    ``{` `        ``int` `N = mat.length;`   `        ``// Stores the last row` `        ``int` `ei = N - ``1` `- i;`   `        ``// Stores the last column` `        ``int` `ej = N - ``1` `- j;`   `        ``// Perform the swaps` `        ``int` `temp = mat[i][j];` `        ``mat[i][j] = mat[ej][i];` `        ``mat[ej][i] = mat[ei][ej];` `        ``mat[ei][ej] = mat[j][ei];` `        ``mat[j][ei] = temp;` `    ``}`   `    ``// Function to rotate non - diagonal` `    ``// elements of the matrix K times in` `    ``// clockwise direction` `    ``static` `void` `rotate(``int` `mat[][], ``int` `N, ``int` `K)` `    ``{` `        ``// Update K to K % 4` `        ``K = K % ``4``;`   `        ``// Iterate until K is positive` `        ``while` `(K-- > ``0``) {`   `            ``// Iterate each up to N/2-th row` `            ``for` `(``int` `i = ``0``; i < N / ``2``; i++) {`   `                ``// Iterate each column` `                ``// from i to N - i - 1` `                ``for` `(``int` `j = i; j < N - i - ``1``; j++) {`   `                    ``// Check if the element` `                    ``// at i, j is not a` `                    ``// diagonal element` `                    ``if` `(i != j && (i + j) != N - ``1``) {`   `                        ``// Perform the swapping` `                        ``performSwap(mat, i, j);` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// Print the matrix` `        ``print(mat);` `    ``}` `  `  `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `K = ``5``;` `        ``int` `mat[][] = {` `            ``{ ``1``, ``2``, ``3``, ``4` `},` `            ``{ ``6``, ``7``, ``8``, ``9` `},` `            ``{ ``11``, ``12``, ``13``, ``14` `},` `            ``{ ``16``, ``17``, ``18``, ``19` `},` `        ``};` `      `  `        ``int` `N = mat.length;` `        ``rotate(mat, N, K);` `    ``}` `}`   `// This code is contributed by Kingash.`

## Python3

 `# Python3 program for the above approach`   `# Function to print the matrix` `def` `printMat(mat):` `  `  `    ``# Iterate over the rows` `    ``for` `i ``in` `range``(``len``(mat)):`   `        ``# Iterate over the columns` `        ``for` `j ``in` `range``(``len``(mat[``0``])):`   `            ``# Print the value` `            ``print``(mat[i][j], end ``=` `" "``)` `            `  `        ``print``()`   `# Function to perform the swapping of` `# matrix elements in clockwise manner` `def` `performSwap(mat, i, j):` `  `  `    ``N ``=` `len``(mat)`   `    ``# Stores the last row` `    ``ei ``=` `N ``-` `1` `-` `i`   `    ``# Stores the last column` `    ``ej ``=` `N ``-` `1` `-` `j`   `    ``# Perform the swaps` `    ``temp ``=` `mat[i][j]` `    ``mat[i][j] ``=` `mat[ej][i]` `    ``mat[ej][i] ``=` `mat[ei][ej]` `    ``mat[ei][ej] ``=` `mat[j][ei]` `    ``mat[j][ei] ``=` `temp`   `# Function to rotate non - diagonal` `# elements of the matrix K times in` `# clockwise direction` `def` `rotate(mat, N, K):`   `    ``# Update K to K % 4` `    ``K ``=` `K ``%` `4`   `    ``# Iterate until K is positive` `    ``while` `(K > ``0``):`   `        ``# Iterate each up to N/2-th row` `        ``for` `i ``in` `range``(``int``(N ``/` `2``)):`   `            ``# Iterate each column` `            ``# from i to N - i - 1` `            ``for` `j ``in` `range``(i, N ``-` `i ``-` `1``):`   `                ``# Check if the element` `                ``# at i, j is not a` `                ``# diagonal element` `                ``if` `(i !``=` `j ``and` `(i ``+` `j) !``=` `N ``-` `1``):`   `                    ``# Perform the swapping` `                    ``performSwap(mat, i, j)` `                    `  `        ``K ``-``=` `1` `                    `  `    ``# Print the matrix` `    ``printMat(mat)`   `# Driver Code` `K ``=` `5` `mat ``=` `[ [ ``1``, ``2``, ``3``, ``4` `],` `        ``[ ``6``, ``7``, ``8``, ``9` `],` `        ``[ ``11``, ``12``, ``13``, ``14` `],` `        ``[ ``16``, ``17``, ``18``, ``19` `] ]` `N ``=` `len``(mat)`   `rotate(mat, N, K)`   `# This code is contributed by Dharanendra L V.`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG {`   `    ``// Function to print the matrix` `    ``static` `void` `print(``int``[, ] mat)` `    ``{` `        ``// Iterate over the rows` `        ``for` `(``int` `i = 0; i < mat.GetLength(0); i++) {`   `            ``// Iterate over the columns` `            ``for` `(``int` `j = 0; j < mat.GetLength(1); j++)`   `                ``// Print the value` `                ``Console.Write(mat[i, j] + ``" "``);`   `            ``Console.WriteLine();` `        ``}` `    ``}`   `    ``// Function to perform the swapping of` `    ``// matrix elements in clockwise manner` `    ``static` `void` `performSwap(``int``[, ] mat, ``int` `i, ``int` `j)` `    ``{` `        ``int` `N = mat.GetLength(0);`   `        ``// Stores the last row` `        ``int` `ei = N - 1 - i;`   `        ``// Stores the last column` `        ``int` `ej = N - 1 - j;`   `        ``// Perform the swaps` `        ``int` `temp = mat[i, j];` `        ``mat[i, j] = mat[ej, i];` `        ``mat[ej, i] = mat[ei, ej];` `        ``mat[ei, ej] = mat[j, ei];` `        ``mat[j, ei] = temp;` `    ``}`   `    ``// Function to rotate non - diagonal` `    ``// elements of the matrix K times in` `    ``// clockwise direction` `    ``static` `void` `rotate(``int``[, ] mat, ``int` `N, ``int` `K)` `    ``{` `        ``// Update K to K % 4` `        ``K = K % 4;`   `        ``// Iterate until K is positive` `        ``while` `(K-- > 0) {`   `            ``// Iterate each up to N/2-th row` `            ``for` `(``int` `i = 0; i < N / 2; i++) {`   `                ``// Iterate each column` `                ``// from i to N - i - 1` `                ``for` `(``int` `j = i; j < N - i - 1; j++) {`   `                    ``// Check if the element` `                    ``// at i, j is not a` `                    ``// diagonal element` `                    ``if` `(i != j && (i + j) != N - 1) {`   `                        ``// Perform the swapping` `                        ``performSwap(mat, i, j);` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// Print the matrix` `        ``print(mat);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{`   `        ``int` `K = 5;` `        ``int``[, ] mat = {` `            ``{ 1, 2, 3, 4 },` `            ``{ 6, 7, 8, 9 },` `            ``{ 11, 12, 13, 14 },` `            ``{ 16, 17, 18, 19 },` `        ``};`   `        ``int` `N = mat.GetLength(0);` `        ``rotate(mat, N, K);` `    ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

```  1 11  6  4
17  7  8  2
18 12 13  3
16 14  9 19```

Time Complexity: O(N2)
Auxiliary Space: O(1), since no extra space has been taken.

My Personal Notes arrow_drop_up