In this post, we will solve HackerRank Matrix Layer Rotation Problem Solution.
You are given a 2D matrix of dimension m x n and a positive integer r. You have to rotate the matrix r times and print the resultant matrix. Rotation should be in anti-clockwise direction.
Rotation of a 4×5 matrix is represented by the following figure. Note that in one rotation, you have to shift elements by one step only.
It is guaranteed that the minimum of m and n will be even.
As an example rotate the Start matrix by 2:
Start First Second
1 2 3 4 2 3 4 5 3 4 5 6
12 1 2 5 -> 1 2 3 6 -> 2 3 4 7
11 4 3 6 12 1 4 7 1 2 1 8
10 9 8 7 11 10 9 8 12 11 10 9
Function Description
Complete the matrixRotation function in the editor below.
matrixRotation has the following parameter(s):
- int matrix[m][n]: a 2D array of integers
- int r: the rotation factor
Prints
It should print the resultant 2D integer array and return nothing. Print each row on a separate line as space-separated integers.
Input Format
The first line contains three space separated integers, m. n. and r, the number of rows and
columns in matrix, and the required rotation.
The next m lines contain n space-separated integers representing the elements of a row of
matrix.
Sample Input
Sample Input #01
STDIN Function ----- -------- 4 4 2 rows m = 4, columns n = 4, rotation factor r = 2 1 2 3 4 matrix = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]] 5 6 7 8 9 10 11 12 13 14 15 16
Sample Output #01
3 4 8 12
2 11 10 16
1 7 6 15
5 9 13 14
Explanation #01
The matrix is rotated through two rotations.
1 2 3 4 2 3 4 8 3 4 8 12
5 6 7 8 1 7 11 12 2 11 10 16
9 10 11 12 -> 5 6 10 16 -> 1 7 6 15
13 14 15 16 9 13 14 15 5 9 13 14
Sample Input #02
5 4 7
1 2 3 4
7 8 9 10
13 14 15 16
19 20 21 22
25 26 27 28
Sample Output #02
28 27 26 25
22 9 15 19
16 8 21 13
10 14 20 7
4 3 2 1
Explanation 02
The various states through 7 rotations:
1 2 3 4 2 3 4 10 3 4 10 16 4 10 16 22
7 8 9 10 1 9 15 16 2 15 21 22 3 21 20 28
13 14 15 16 -> 7 8 21 22 -> 1 9 20 28 -> 2 15 14 27 ->
19 20 21 22 13 14 20 28 7 8 14 27 1 9 8 26
25 26 27 28 19 25 26 27 13 19 25 26 7 13 19 25
10 16 22 28 16 22 28 27 22 28 27 26 28 27 26 25
4 20 14 27 10 14 8 26 16 8 9 25 22 9 15 19
3 21 8 26 -> 4 20 9 25 -> 10 14 15 19 -> 16 8 21 13
2 15 9 25 3 21 15 19 4 20 21 13 10 14 20 7
1 7 13 19 2 1 7 13 3 2 1 7 4 3 2 1
Sample Input #03
2 2 3
1 1
1 1
Sample Output #03
1 1
1 1
Explanation #03
All of the elements are the same, so any rotation will repeat the same matrix.
Matrix Layer Rotation C Solution
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
int main() {
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
int row,col,rot;
int i,j,current;
int rIndex,cIndex;
int min1,min2,frameNumber;
int horRot,verRot,currentRot;
int rotmat[300][300];
scanf("%d %d %d",&row,&col,&rot);
for(i=0;i<row;i++)
{
for(j=0;j<col;j++)
{
scanf("%d",¤t);
min1=fmin(i,j);
min2=fmin(col-1-j,row-1-i);
frameNumber=fmin(min1,min2);
horRot=col-1-2*frameNumber;
verRot=row-1-2*frameNumber;
currentRot=rot%(2*(horRot+verRot));
rIndex=i;
cIndex=j;
while(currentRot!=0)
{
if(rIndex==frameNumber && cIndex>frameNumber)
{
cIndex--;
}
else if(cIndex==frameNumber && rIndex<(row-1-frameNumber))
{
rIndex++;
}
else if(rIndex==(row-1-frameNumber) && cIndex<(col-1-frameNumber))
{
cIndex++;
}
else if(cIndex==(col-1-frameNumber) && rIndex>frameNumber)
{
rIndex--;
}
currentRot--;
}
rotmat[rIndex][cIndex]=current;
}
}
for(i=0;i<row;i++)
{
for(j=0;j<col;j++)
{
printf("%d ",rotmat[i][j]);
}
printf("\n");
}
return 0;
}Matrix Layer Rotation C++ Solution
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int M,N,R; cin >> M >> N >> R;
vector<vector<int>> v(M, vector<int>(N,0));
for(auto&r:v) for(auto&c:r) cin >> c;
int nlayer = min(N,M)/2;
for (int i=0; i < nlayer; ++i) {
// cerr << "layer#"<<i<<endl;
vector<int*> layer;
int nrows = M-2*i;
int ncols = N-2*i;
// cerr << "nrows="<<nrows << endl << "ncols="<<ncols<<endl;
for (int c=i; c < N-i-1; ++c) layer.push_back(&v[i][c]); // top
// for (auto i:layer) cerr << *i <<" ";cerr<<endl;
for (int r=i; r < M-1-i; ++r) layer.push_back(&v[r][N-1-i]); // right
//for (auto i:layer) cerr <<*i <<" ";cerr<<endl;
for (int c=i; c < N-i-1; ++c) layer.push_back(&v[M-1-i][N-1-c]); // bottom
// for (auto i:layer) cerr <<*i <<" ";cerr<<endl;
for (int r=i; r < M-1-i; ++r) layer.push_back(&v[M-1-r][i]); // left
//for (auto i:layer) cerr <<*i <<" ";cerr<<endl;
vector<int> l(layer.size());
transform(layer.begin(),layer.end(),l.begin(),[](auto p){return*p;});
int r = R % (l.size());
rotate(l.begin(), l.begin()+r, l.end());
//for (int i:l) cerr << i << " "; cerr << endl;
for (size_t i=0; i < l.size(); ++i) {
*layer[i] = l[i];
}
// cerr<<endl;
}
for(auto&r:v) {
for(auto&c:r) cout << c << " ";
cout << endl;
}
return 0;
}Matrix Layer Rotation C Sharp Solution
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
public class MatrixRotation
{
public Int32 RowNumber { get; set; }
public Int32 ColumnNumber { get; set;}
public Int32 RotationNumer { get; set; }
public Int32[,] Matrix;
public Int32[,] Matrix_Rotation;
/// <summary>
/// cross line position, [0,0],[1,1]...[n,n]
/// </summary>
public List<Tuple<Int32,Int32>> DiagonalNumber { get; set; }
public void PrintMatrix(Int32[,] matrix)
{
Int32 lengthX = matrix.GetLength(1);
Int32 lengthY = matrix.GetLength(0);
for (Int32 y = 0; y < lengthY; y++)
{
for (Int32 x = 0; x < lengthX; x++)
{
if(x==lengthX-1)
Console.Write(matrix[y, x]);
else
{
Console.Write(matrix[y, x] + " ");
}
}
Console.WriteLine();
}
}
public Int32[,] RotateRight(Int32[,] matrix)
{
Int32 lengthY = matrix.GetLength(0);
Int32 lengthX = matrix.GetLength(1);
Int32[,] result = new Int32[lengthX, lengthY];
for (Int32 y = 0; y < lengthY; y++)
for (Int32 x = 0; x < lengthX; x++)
result[x, y] = matrix[lengthY - 1 - y, x];
return result;
}
public void Test()
{
TestRotation(new Int32[4, 4] { { 1, 2,3,4 }, { 5,6,7,8 }, { 9,10,11,12 },{13,14,15,16} });
Console.WriteLine();
TestRotation(new Int32[2, 3] { { 0, 1, 2 }, { 3, 4, 5 } });
}
public void TestRotation(Int32[,] matrix)
{
Console.WriteLine("the original matrix:");
PrintMatrix(matrix);
Console.WriteLine();
Console.WriteLine("the right rotated matrix:");
PrintMatrix(RotateRight(matrix));
Console.WriteLine();
//Console.WriteLine("the left rotated matrix:");
//PrInt32Matrix(RotateLeft(matrix));
}
public void CreateEmptyMatrix()
{
Matrix=new Int32[RowNumber,ColumnNumber];
Matrix_Rotation=new Int32[RowNumber,ColumnNumber];
}
public void CreateMatrix(Int32 rowIdx, string s)
{
string[] rowStringList = s.Split(' ');
for (Int32 i = 0; i < ColumnNumber; i++)
{
Matrix[rowIdx, i] = Convert.ToInt32(rowStringList[i]);
Matrix_Rotation[rowIdx, i] = Convert.ToInt32(rowStringList[i]);
}
}
public void PrintMatrixRotation()
{
if (Matrix.Length > 0 && RowNumber > 0 && ColumnNumber > 0)
{
DiagonalNumber = new List<Tuple<Int32, Int32>>();
// calculate the each rotation index
// for example
// row =10, colunn =10
// first round is (row=0, column=9)
// second round is (row =1, column=8)
// .... etc (row = 4, column =5)
for (Int32 rowIdx = 0, colIdx = 0; rowIdx < RowNumber && colIdx < ColumnNumber; rowIdx++, colIdx++)
{
if (DiagonalNumber.Count(x => x.Item1 == rowIdx && x.Item2 == colIdx) == 0)
{
DiagonalNumber.Add(new Tuple<int,int>(rowIdx,colIdx));
List<Tuple<Int32, Int32>> currentRotation = new List<Tuple<Int32, Int32>>();
int ColNumberInCurrentRoation = ColumnNumber - 2*colIdx;
int RowNumberInCurrentRotation = RowNumber - 2*rowIdx;
//Move Right
for (Int32 col = colIdx; col <= ColumnNumber - colIdx - 1; col++)
{
if (col == rowIdx && DiagonalNumber.Count(x => x.Item1 == rowIdx && x.Item2 == colIdx) == 0)
DiagonalNumber.Add(new Tuple<Int32, Int32>(rowIdx, col));
currentRotation.Add(new Tuple<Int32, Int32>(rowIdx, col));
}
//Move Down
for (Int32 row = rowIdx + 1; row <= RowNumber - rowIdx - 1; row++)
{
if (!currentRotation.Any(x => x.Item1 == row &&
x.Item2 == ColumnNumber - colIdx - 1))
{
currentRotation.Add(new Tuple<Int32, Int32>(row, ColumnNumber - colIdx - 1));
if (ColumnNumber - colIdx - 1 == row &&
DiagonalNumber.Count(x => x.Item1 == rowIdx && x.Item2 == ColumnNumber - colIdx - 1) == 0)
DiagonalNumber.Add(new Tuple<Int32, Int32>(row, ColumnNumber - colIdx - 1));
}
}
//Move Left
for (Int32 col = ColumnNumber - colIdx - 1 - 1; col >= colIdx; col--)
{
if (!currentRotation.Any(x => x.Item1 == RowNumber - rowIdx - 1 &&
x.Item2 == col))
{
currentRotation.Add(new Tuple<Int32, Int32>(RowNumber - rowIdx - 1, col));
if (RowNumber - rowIdx - 1 == col &&
DiagonalNumber.Count(x => x.Item1 == RowNumber - rowIdx - 1 && x.Item2 == col) == 0)
DiagonalNumber.Add(new Tuple<Int32, Int32>(RowNumber - rowIdx - 1, col));
}
}
//Move Up
for (Int32 row = RowNumber - rowIdx - 1 - 1; row >= rowIdx; row--)
{
if (!currentRotation.Any(x => x.Item1 == row &&
x.Item2 == colIdx))
{
if (row == colIdx &&
DiagonalNumber.Count(x => x.Item1 == row && x.Item2 == colIdx)==0)
{
DiagonalNumber.Add(new Tuple<Int32, Int32>(row, colIdx));
}
currentRotation.Add(new Tuple<Int32, Int32>(row, colIdx));
}
}
// shift matrix based on current rotation position list
for (int shiftIdx = 0; shiftIdx < RotationNumer % ((ColNumberInCurrentRoation+RowNumberInCurrentRotation - 2) * 2); shiftIdx++)
ShiftMatrix(currentRotation);
}
else
{
break;
}
}
}
//PrInt32Matrix(Matrix);
//PrInt32Matrix(Matrix_Rotation);
}
//private void PrInt32Matrix(Int32[,] Matrix_Rotation)
//{
// if (Matrix_Rotation.Length > 0)
// {
// for (Int32 i = 0; i < Matrix_Rotation.Length; i++)
// {
// for (Int32 j = 0; j < Matrix_Rotation.Rank; j++)
// {
// Console.Write("{0} ", Matrix_Rotation[i, j]);
// }
// Console.WriteLine();
// }
// }
//}
private void ShiftMatrix(List<Tuple<Int32, Int32>> rotationList)
{
if (rotationList.Count > 0)
{
Int32 firstNumber = 0;
for (Int32 i = 0; i <= rotationList.Count; i++)
{
if (i == 0)
{
Int32 item1 = rotationList[i].Item1;
Int32 item2 = rotationList[i].Item2;
Int32 v = Matrix_Rotation[item1, item2];
firstNumber = Matrix_Rotation[rotationList[i].Item1, rotationList[i].Item2];
}
else if (i == rotationList.Count)
{
Int32 item1 = rotationList[i-1].Item1;
Int32 item2 = rotationList[i-1].Item2;
Int32 v = Matrix_Rotation[item1, item2];
Matrix_Rotation[rotationList[i-1].Item1, rotationList[i-1].Item2] = firstNumber;
}
else
{
Int32 item1 = rotationList[i].Item1;
Int32 item2 = rotationList[i].Item2;
Int32 v_pre = Matrix_Rotation[rotationList[i - 1].Item1, rotationList[i - 1].Item2];
Int32 v = Matrix_Rotation[rotationList[i].Item1, rotationList[i].Item2];
Matrix_Rotation[rotationList[i - 1].Item1, rotationList[i - 1].Item2] =
Matrix_Rotation[rotationList[i].Item1, rotationList[i].Item2];
}
}
}
}
static void Main(string[] args)
{
MatrixRotation mrObjRotation = new MatrixRotation();
string input = Console.ReadLine();
string[] rowcols= input.Split(' ');
int rowIdx = 0;
mrObjRotation.RowNumber = Convert.ToInt32(rowcols[0]);
mrObjRotation.ColumnNumber = Convert.ToInt32(rowcols[1]);
mrObjRotation.RotationNumer = Convert.ToInt32(rowcols[2]);
mrObjRotation.CreateEmptyMatrix();
string inputRow = Console.ReadLine();
while (!string.IsNullOrEmpty(inputRow))
{
mrObjRotation.CreateMatrix(rowIdx, inputRow);
inputRow = Console.ReadLine();
rowIdx++;
}
mrObjRotation.PrintMatrixRotation();
mrObjRotation.PrintMatrix(mrObjRotation.Matrix_Rotation);
}
}
}Matrix Layer Rotation Java Solution
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
class Result {
/*
* Complete the 'matrixRotation' function below.
*
* The function accepts following parameters:
* 1. 2D_INTEGER_ARRAY matrix
* 2. INTEGER r
*
*
*
*/
public static void matrixRotation(List<List<Integer>> matrix, int rotate) {
List<Integer> layerone=null;
int cols = matrix.get(0).size();
int rows = matrix.size();
int rows_start =0;
int rows_end=rows-1;
int cols_start=0;
int cols_end=cols-1;
// the number of layer is the min(M,N)/2
int numboflayer = matrix.size()<matrix.get(0).size()?matrix.size()/2:matrix.get(0).size()/2;
List<Integer> layerone_order = null;
Map<Integer,List<Integer>> mapLayers = new HashMap<>();
// create matrix layer
for(int layer=0;layer<numboflayer;layer++)
{
layerone_order = new ArrayList<>();
layerone=new ArrayList<>();
rows_start=layer;
rows_end=rows-1-layer;
cols_start=layer;
cols_end=cols-1-layer;
layerone.addAll(matrix.get(rows_start).subList(cols_start,cols_end));
for(int r=rows_start;r<=rows_end;r++)
{
layerone.add(matrix.get(r).get(cols_end));
}
List<Integer> tempList = new ArrayList<>();
tempList.addAll(matrix.get(rows_end).subList(cols_start,cols_end));
Collections.reverse(tempList);
layerone.addAll(tempList);
for(int i=rows_end-1;i>rows_start;i--)
{
layerone.add(matrix.get(i).get(rows_start));
}
layerone_order.addAll(layerone.subList(rotate%layerone.size(),layerone.size()));
layerone_order.addAll(layerone.subList(0,rotate%layerone.size()));
mapLayers.put(layer,layerone_order);
}
// print layer matrix rotation
//aprintLayers(mapLayers);
int index=0;
for(int layer=0;layer<numboflayer;layer++)
{
index=0;
rows_start=layer;
rows_end=rows-1-layer;
cols_start=layer;
cols_end=cols-1-layer;
for(int col_layer=0;col_layer<=cols_end-cols_start;col_layer++)
{
matrix.get(rows_start).set(cols_start+col_layer,mapLayers.get(layer).get(col_layer));
}
index=0;
for(int row=rows_start+1;row<rows_end;row++)
{
index++;
matrix.get(row).set(cols_start,mapLayers.get(layer).get(mapLayers.get(layer).size()-index));
matrix.get(row).set(cols_end,mapLayers.get(layer).get(cols_end-cols_start+index));
}
for(int col_layer=0;col_layer<=cols_end-cols_start;col_layer++) {
matrix.get(rows_end).set(cols_start+col_layer,mapLayers.get(layer).get(mapLayers.get(layer).size()-index-col_layer-1));
}
}
printMatrix(matrix);
}
private static void printLayers(Map<Integer,List<Integer>> mapLayers)
{
mapLayers.forEach((key,value)->{
System.out.print(" - " + key + " - ");
value.stream().forEach(el->{
System.out.print(el+" ");
});
});
System.out.println("");
}
private static void printMatrix(List<List<Integer>> matrix)
{
matrix.stream().forEach(row->{
row.stream().forEach(col->{
System.out.print(col + " ");
});
System.out.println("");
});
}
}
public class Solution {
public static void main(String[] args) throws IOException {
try(BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in)))
{
String line = bufferedReader.readLine();
//System.out.println(line);
//System.out.println(line.replaceAll("\\s+$", "").split(" "));
String[] firstMultipleInput = line.replaceAll("\\s+$", "").split(" ");
int m = Integer.parseInt(firstMultipleInput[0]);
int n = Integer.parseInt(firstMultipleInput[1]);
int r = Integer.parseInt(firstMultipleInput[2]);
List<List<Integer>> matrix = new ArrayList<>();
IntStream.range(0, m).forEach(i -> {
try {
matrix.add(
Stream.of(bufferedReader.readLine().replaceAll("\\s+$", "").split(" "))
.map(Integer::parseInt)
.collect(Collectors.toList())
);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
});
Result.matrixRotation(matrix, r);
}
catch(IOException io)
{
throw new RuntimeException(io);
}
}
}Matrix Layer Rotation JavaScript Solution
function processData(input) {
var lines = input.split('\n');
var params = lines[0].split(' ').map(Number);
var numRows = params[0];
var numCols = params[1];
var numRotations = params[2];
var a = [];
for(var i=0; i<numRows; i++){
var row = lines[i+1].split(' ').map(Number);
a.push(row);
}
var sequences = readArray(a, numRows, numCols);
sequences.forEach(function(sequence){
rotateSequence(sequence, numRotations);
});
var result = writeArray(sequences, numRows, numCols);
printResult(result);
}
function readArray(a, numRows, numCols){
var sequences = [];
var numSequences = Math.ceil(Math.min(numRows/2, numCols/2));
for(var i=0; i<numSequences; i++){
var sequence = [];
var p = { x:i, y:i };
var d = { x:0, y:1 };
var hasCompleted = false;
sequence.push(a[p.y][p.x]);
while(!hasCompleted){
p.x += d.x;
p.y += d.y;
if(p.y >= numRows-i){
d.x = 1;
d.y = 0;
p.x += 1;
p.y -= 1;
} else if(p.x >= numCols-i){
d.x = 0;
d.y = -1;
p.x -= 1;
p.y -= 1;
} else if(p.y < i){
d.x = -1;
d.y = 0;
p.x -= 1;
p.y += 1;
}
if(p.x == i && p.y == i){
hasCompleted = true;
} else {
sequence.push(a[p.y][p.x]);
}
}
sequences.push(sequence);
}
return sequences;
}
function rotateSequence(sequence, numRotations){
numRotations = numRotations % sequence.length;
var temp = sequence.splice(sequence.length-numRotations, numRotations);
sequence.unshift.apply(sequence, temp);
}
function writeArray(sequences, numRows, numCols){
var a = [];
for(var i=0; i<numRows; i++){
a[i] = [];
}
sequences.forEach(function(sequence, i){
var j = 0;
var p = { x:i, y:i };
var d = { x:0, y:1 };
var hasCompleted = false;
a[p.y][p.x] = sequence[j];
while(!hasCompleted){
p.x += d.x;
p.y += d.y;
if(p.y >= numRows-i){
d.x = 1;
d.y = 0;
p.x += 1;
p.y -= 1;
} else if(p.x >= numCols-i){
d.x = 0;
d.y = -1;
p.x -= 1;
p.y -= 1;
} else if(p.y < i){
d.x = -1;
d.y = 0;
p.x -= 1;
p.y += 1;
}
if(p.x == i && p.y == i){
hasCompleted = true;
} else {
j += 1;
a[p.y][p.x] = sequence[j];
}
}
});
return a;
}
function printResult(a){
a.forEach(function(row){
console.log(row.join(' '));
});
}
process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
_input += input;
});
process.stdin.on("end", function () {
processData(_input);
});Matrix Layer Rotation Python Solution
m,n,r = list( map( int, input().split() ) )
loops = int( min( m,n ) / 2 )
def roundtrip( i, m, n ):
for r in range( i, m-i-1 ):
yield ( r, i )
for r in range( i, n-i-1 ):
yield ( m-i-1, r )
for r in range( m-i-1, i, -1 ):
yield ( r, n-i-1 )
for r in range( n-i-1, i, -1 ):
yield ( i, r )
posToLoop = {}
loopToPos = {}
loopMax = {}
for l in range(loops):
idx = 0
for i in roundtrip( l, m, n ):
posToLoop[ i ] = ( l, idx )
loopToPos[ ( l, idx ) ] = i
idx += 1
loopMax[ l ] = idx
matrix = [[0 for x in range(n)] for x in range(m)]
y = 0
for i in range( m ):
line = input().split()
x = 0
for num in line:
l,p = posToLoop[ (y,x) ]
p = ( p + r ) % loopMax[ l ]
p = loopToPos[ (l,p) ]
matrix[ p[0] ][ p[1] ] = num
x += 1
y += 1
for l in matrix:
print( ' '.join( l ) )Other Solutions
