Rotate a matrix by one element: is there an easier/simpler implementation? - arrays

Question

I was written this code to rotate the matrix elements one by one.
I wanted to do this on my own but I am stuck in this position someone please find what is the problem in my code and suggest me there is any easy implementation other than this.
#include<iostream>
using namespace std;
void rotate(int a[][10],int r,int c)
{
int b[10][10];
// Copying the input matrix 2d array to temp array
for (int x = 0; x < r; x++)
{
for (int y = 0; y < c; y++)
{
b[x][y] = a[x][y];
}
}
//Rotation process
int i = 0;
int j = 0;
int flag = 0;
while (flag == 0)
{
if (i == 0 && j < c-1)
{
b[i][j+1] = a[i][j];
j++;
}
else if (j == c-1 && i < r-1)
{
b[i+1][j] = a[i][j];
i++;
}
else if (i == r-1 && j <= c-1 && j > 0)
{
b[i][j-1]=a[i][j];
j--;
}
else if (j == 0 && i <= r-1)
{
if (i==0 && j==0)
{
//to break the loop
flag = 1;
}
b[i-1][j] = a[i][j];
i--;
}
}
for (int k = 0; k < r; k++)
{
for (int l = 0; l < c; l++)
{
cout<<"\t"<<b[k][l];
}
cout<<endl;
}
}
int main()
{
int a[10][10],row,col;
cout<<"Enter no of rows : ";
cin>>row;
cout<<"Enter no of columns : ";
cin>>col;
// Getting array elements
cout<<"Enter "<<row<<"X"<<col<<" matrix elements : ";
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
cin>>a[i][j];
}
}
rotate(a,row,col);
cout<<endl;
system("pause");
return 0;
}
This code is not working. Someone help me to find what wrong with this code or suggest me another way.
Thank you.

Answer 1

If I were solving this, I might use 4 independent loops and a single variable to hold the value to carry forward (can be read from the original or matrix copy). While perhaps more repetitive than some approaches, it also removes needing to track 'which direction' state or delta movement variables.
In pseudo-code, it might look like this:
carry = m[0][0]
x, y = 1, 0 # start at (1,0) so we end on (0,0)
# go right from (1,0) to (cols-1,0)
while x < cols:
temp = m[x][y] # hold value of this cell
m[x][y] = carry # replace it with the carried-over value
carry = temp # and forward the previous value as the next carry
x += 1 # update position
# reset back to valid index (avoid additional check in loop)
x -= 1
# do same for other directions around
# the movement is thus:
# (1,0) -> (cols-1,0) NW -> NE
# (cols-1,0) -> (cols-1,rows-1) NE -> SE
# (cols-1,rows-1) -> (0,rows-1) SE -> SW
# (0,rows-1) -> (0,0) SW -> NW
A 1xN or Nx1 matrix might need additional consideration depending on expectations.
Another approach is to use delta variables to move. Think of a little turtle that walks straight and turns right when walking into a wall. The terminal condition is once again set as (0,0) which can be checked at the end of the logic - in this case when the turtle attempts to walk North into a wall, we know it was from (0,0) and the path is completed.
This approach feels less repetitive while maintaining simple state transitions.
carry = m[0][0]
x, y = 1, 0 # start at (1,0)
dx, dy = 1, 0 # and facing East
while true:
# could also use prev_x and prev_y instead of a carry
temp = m[x][y]
m[x][y] = carry
carry = temp
# move / walk
x += dx
y += dy
# turn right when running into a wall
# at most one bound can be violated at a time
if x >= cols:
dx, dy = 0, 1 # face South (was facing East)
x = cols - 1
else if y >= rows:
dx, dy = -1, 0 # face West (was facing South)
y = rows - 1
else if x < 0:
dx, dy = 0, -1 # face North (was facing West)
x = 0
else if y < 0:
# at (0,0) walking North - finished!
break