Skip to content
Related Articles

Related Articles

Improve Article

Rotate the matrix right by K times

  • Difficulty Level : Medium
  • Last Updated : 05 May, 2021

Given a matrix of size N*M, and a number K. We have to rotate the matrix K times to the right side. 
Examples: 
 

Input :  N = 3, M = 3, K = 2
         12 23 34
         45 56 67
         78 89 91 

Output : 23 34 12
         56 67 45
         89 91 78 


Input :  N = 2, M = 2, K = 2
         1 2
         3 4
         
Output : 1 2
         3 4

 

A simple yet effective approach is to consider each row of the matrix as an array and perform an array rotation. This can be done by copying the elements from K to end of array to starting of array using temporary array. And then the remaining elements from start to K-1 to end of the array.
Lets take an example: 
 

 



C++




// CPP program to rotate a matrix right by k times
#include <iostream>
 
// size of matrix
#define M 3
#define N 3
 
using namespace std;
 
// function to rotate matrix by k times
void rotateMatrix(int matrix[][M], int k) {
  // temporary array of size M
  int temp[M];
 
  // within the size of matrix
  k = k % M;
 
  for (int i = 0; i < N; i++) {
 
    // copy first M-k elements to temporary array
    for (int t = 0; t < M - k; t++)
      temp[t] = matrix[i][t];
 
    // copy the elements from k to end to starting
    for (int j = M - k; j < M; j++)
      matrix[i][j - M + k] = matrix[i][j];
 
    // copy elements from temporary array to end
    for (int j = k; j < M; j++)
      matrix[i][j] = temp[j - k];
  }
}
 
// function to display the matrix
void displayMatrix(int matrix[][M]) {
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < M; j++)
      cout << matrix[i][j] << " ";
    cout << endl;
  }
}
 
// Driver's code
int main() {
  int matrix[N][M] = {{12, 23, 34},
                     {45, 56, 67},
                     {78, 89, 91}};
  int k = 2;
 
  // rotate matrix by k
  rotateMatrix(matrix, k);
 
  // display rotated matrix
  displayMatrix(matrix);
 
  return 0;
}

Java




// Java program to rotate a matrix
// right by k times
 
class GFG
{
    // size of matrix
    static final int M=3;
    static final int N=3;
     
    // function to rotate matrix by k times
    static void rotateMatrix(int matrix[][], int k)
    {
        // temporary array of size M
        int temp[]=new int[M];
         
        // within the size of matrix
        k = k % M;
         
        for (int i = 0; i < N; i++)
        {
         
            // copy first M-k elements
            // to temporary array
            for (int t = 0; t < M - k; t++)
            temp[t] = matrix[i][t];
         
            // copy the elements from k
            // to end to starting
            for (int j = M - k; j < M; j++)
            matrix[i][j - M + k] = matrix[i][j];
         
            // copy elements from
            // temporary array to end
            for (int j = k; j < M; j++)
            matrix[i][j] = temp[j - k];
        }
    }
     
    // function to display the matrix
    static void displayMatrix(int matrix[][])
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++)
            System.out.print(matrix[i][j] + " ");
            System.out.println();
        }
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int matrix[][] = {{12, 23, 34},
                        {45, 56, 67},
                        {78, 89, 91}};
    int k = 2;
     
    // rotate matrix by k
    rotateMatrix(matrix, k);
     
    // display rotated matrix
    displayMatrix(matrix);
    }
}
 
// This code is contributed by Anant Agarwal.

Python3




# Python program to rotate
# a matrix right by k times
 
# size of matrix
M = 3
N = 3
matrix = [[12, 23, 34],
          [45, 56, 67],
          [78, 89, 91]]
 
# function to rotate
# matrix by k times
def rotateMatrix(k) :
 
    global M, N, matrix
     
    # temporary array
    # of size M
    temp = [0] * M
     
    # within the size
    # of matrix
    k = k % M
     
    for i in range(0, N) :
     
        # copy first M-k elements
        # to temporary array
        for t in range(0, M - k) :
            temp[t] = matrix[i][t]
     
        # copy the elements from
        # k to end to starting
        for j in range(M - k, M) :
            matrix[i][j - M + k] = matrix[i][j]
     
        # copy elements from
        # temporary array to end
        for j in range(k, M) :
            matrix[i][j] = temp[j - k]
     
# function to display
# the matrix
def displayMatrix() :
 
    global M, N, matrix
    for i in range(0, N) :
     
        for j in range(0, M) :
            print ("{} " .
                   format(matrix[i][j]), end = "")
        print ()
 
# Driver code
k = 2
 
# rotate matrix by k
rotateMatrix(k)
 
# display rotated matrix
displayMatrix()
 
# This code is contributed by
# Manish Shaw(manishshaw1)

C#




// C# program to rotate a 
// matrix right by k times
using System;
 
class GFG {
     
    // size of matrix
    static int M=3;
    static int N=3;
     
    // function to rotate matrix by k times
    static void rotateMatrix(int [,] matrix,
                             int k)
    {
         
        // temporary array of size M
        int [] temp=new int[M];
         
        // within the size of matrix
        k = k % M;
         
        for (int i = 0; i < N; i++)
        {
         
            // copy first M-k elements
            // to temporary array
            for (int t = 0; t < M - k; t++)
            temp[t] = matrix[i, t];
         
            // copy the elements from k
            // to end to starting
            for (int j = M - k; j < M; j++)
            matrix[i, j - M + k] = matrix[i, j];
         
            // copy elements from
            // temporary array to end
            for (int j = k; j < M; j++)
            matrix[i, j] = temp[j - k];
        }
    }
     
    // function to display the matrix
    static void displayMatrix(int [,] matrix)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < M; j++)
            Console.Write(matrix[i, j] + " ");
            Console.WriteLine();
        }
    }
     
    // Driver code
    public static void Main ()
    {
        int [,] matrix = {{12, 23, 34},
                          {45, 56, 67},
                          {78, 89, 91}};
        int k = 2;
         
        // rotate matrix by k
        rotateMatrix(matrix, k);
         
        // display rotated matrix
        displayMatrix(matrix);
    }
}
 
// This code is contributed by KRV.

PHP




<?php
// PHP program to rotate
// a matrix right by k times
 
// size of matrix
$M = 3;
$N = 3;
 
// function to rotate
// matrix by k times
function rotateMatrix(&$matrix, $k)
{
    global $M, $N;
     
    // temporary array
    // of size M
    $temp = array();
     
    // within the size
    // of matrix
    $k = $k % $M;
     
    for ($i = 0; $i < $N; $i++)
    {
     
        // copy first M-k elements
        // to temporary array
        for ($t = 0;
             $t < $M - $k; $t++)
        $temp[$t] = $matrix[$i][$t];
     
        // copy the elements from
        // k to end to starting
        for ($j = $M - $k;
             $j < $M; $j++)
        $matrix[$i][$j - $M + $k] =
                    $matrix[$i][$j];
     
        // copy elements from
        // temporary array to end
        for ($j = $k; $j < $M; $j++)
        $matrix[$i][$j] = $temp[$j - $k];
    }
}
 
// function to display
// the matrix
function displayMatrix(&$matrix)
{
    global $M, $N;
    for ($i = 0; $i < $N; $i++)
    {
        for ($j = 0; $j < $M; $j++)
        echo ($matrix[$i][$j]." ");
        echo ("\n");
    }
}
 
// Driver code
$matrix = array(array(12, 23, 34),
                array(45, 56, 67),
                array(78, 89, 91));
$k = 2;
 
// rotate matrix by k
rotateMatrix($matrix, $k);
 
// display rotated matrix
displayMatrix($matrix);
 
// This code is contributed by
// Manish Shaw(manishshaw1)
?>

Javascript




<script>
 
// Javascript program to rotate a matrix
// right by k times   
 
 
// size of matrix
    var M = 3;
     var N = 3;
 
    // function to rotate matrix by k times
    function rotateMatrix(matrix , k)
    {
        // temporary array of size M
        var temp = Array(M).fill(0);
 
        // within the size of matrix
        k = k % M;
 
        for (i = 0; i < N; i++) {
 
            // copy first M-k elements
            // to temporary array
            for (t = 0; t < M - k; t++)
                temp[t] = matrix[i][t];
 
            // copy the elements from k
            // to end to starting
            for (j = M - k; j < M; j++)
                matrix[i][j - M + k] = matrix[i][j];
 
            // copy elements from
            // temporary array to end
            for (j = k; j < M; j++)
                matrix[i][j] = temp[j - k];
        }
    }
 
    // function to display the matrix
    function displayMatrix(matrix) {
        for (i = 0; i < N; i++) {
            for (j = 0; j < M; j++)
                document.write(matrix[i][j] + " ");
            document.write("<br/>");
        }
    }
 
    // Driver code
     
        var matrix = [
        [ 12, 23, 34 ],
        [ 45, 56, 67 ],
        [ 78, 89, 91 ] ];
        var k = 2;
 
        // rotate matrix by k
        rotateMatrix(matrix, k);
 
        // display rotated matrix
        displayMatrix(matrix);
 
// This code contributed by umadevi9616
 
</script>
Output: 
23 34 12 
56 67 45 
89 91 78

 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :