Given a two dimensional array, I would like to iterate through it in a snail mode and print out the elements using one single cycle.
For example if the given array is:
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24
25 26 27 28 29
30 31 32 33 34
The program should print out:
10 15 20 25 30 31 32 33 34 29 24 19 14 13 12 11 16 21 26 27 28 23 18 17 22
So starting from the upper-left corner and arriving to the center of the array.
Here is the solution with one for loop:
It works only when the matrix is: n >= m
#include <iostream>
using namespace std;
int main()
{
// int arr[4][3] = {{0, 9, 8} , {1, 10 , 7} , {2, 11, 6} , {3, 4, 5}};
// int n = 4, m = 3;
int arr[4][4] = {{0, 11, 10, 9} , {1, 12, 15, 8} , {2, 13, 14, 7} , {3, 4, 5, 6}};
int n = 4, m = 4;
int row = 0, col = 0, turn = 0;
bool isTop = true;
for(int nrElem = 0; nrElem <= (n*m); nrElem++)
{
//This part make the left, bottom, right part ( U form )
if((row < n-1-turn) && (col != m-1) && (isTop == true))
{
cout << " " << arr[row][col];
row++;
} else {
if((row == n-1-turn) && (col < m-1-turn))
{
cout << " " << arr[row][col];
col++;
} else {
if((col == m-1-turn) && (row > 0))
{
cout << " " << arr[row][col];
row--;
} else {
isTop = false;
}
}
}
//
//And this do the top backward parsing
if((col > 0) && (isTop == false))
{
cout << " " << arr[row][col];
col--;
} else {
if (isTop == false)
{
isTop = true;
turn++;
row += turn;
col += turn;
}
}
}
cout << endl;
return 0;
}
We can do it with a single cycle without storing additional matrices. The following code assumes that you can use std::vector from C++11 and is based on the example from geeks for geeks. Ofcourse, the algorithm works without std::vector as well. Furthermore, this snail goes clockwise and as an exercise you should change it to make counter clockwise :). [I did not compile the code]
#include <iostream>
#include <vector>
using namespace std;
void printSnail(vector<vector<int>> const &matrix)
{
size_t nRow = matrix.size(); // Number of rows that are not printed yet
size_t nCol = matrix[0].size(); // Number of columns that are not printed yet
size_t k = 0;
size_t l = 0;
// Print all elements in the matrix
while (k < nRow and l < nCol)
{
// Print first row of remaining rows
for (size_t idx = l; idx < nCol; ++idx)
cout << matrix[k][idx] << ' ';
++k;
// Print last column of remaining columns
for (size_t idx = k; idx < nRow; ++idx)
cout << matrix[idx][nCol - 1] << ' ';
--nCol;
// Print last row of remaining rows
if (k < nRow)
{
for (size_t idx = nCol - 1; idx >= l; --idx)
cout << matrix[nRow - 1][idx] << ' ';
--nRow;
}
// Print the first column of the remaining columns
if (l < nCol)
{
for (size_t idx = nRow - 1; idx >= k; --idx)
cout << matrix[idx][l] << ' ';
++l;
}
}
}
Here is how to implement it in Javascript
snail = function(arr) {
let [y, x] = [0, 0];
let [rs, ls, us, ds] = [0, 0, 0, 0]
let [xLimit, yLimit] = [arr.length, arr.length];
let dir = 'right'
const res = []
const len = arr[0].length * arr[0].length
const rowLen = arr[0].length
while (res.length < len) {
res.push(arr[y][x])
switch (dir) {
case 'right':
if (x + 1 < xLimit) {
x++
} else {
dir = 'down'
yLimit = rowLen - ds
rs++
y++
}
break;
case 'down':
if (y + 1 < yLimit) {
y++
} else {
dir = 'left'
xLimit = ls
ds++
x--
}
break;
case 'left':
if (x > xLimit) {
x--
} else {
dir = 'up'
yLimit = ds
ls++
y--
}
break;
case 'up':
if (y > yLimit) {
y--
} else {
dir = 'right'
xLimit = rowLen - rs
us++
x++
}
break;
default:
break;
}
}
return res
}
It's not using any built-in Javascript function so it can be translated to any language
Here is a simple solution to your problem:
Keep a 2D array(checkIfVisited) of the same size(all cells initialized to 0) of that your array, in order to keep track of the cells that are already visited. If (i,j) is 1 then it means that the cell in the original has already been visited.
We iterate the whole array spirally with the help of the dir variable which keeps track of which direction we are currently traversing.
dir = 0 means moving downwards, 1 means moving rightwards, 2 means moving upwards, 3 means moving leftwards.
We change directions when either i and j goes out of limits or when the next cell to be traversed has already been traversed before by doing a lookup from the checkIfVisited array.
I have a simple C++ implementation of the above algorithm:
#include <iostream>
using namespace std;
int main()
{
int arr[5][5] = {10, 11, 12, 13, 14,
15, 16, 17, 18, 19,
20, 21, 22, 23, 24,
25, 26, 27, 28, 29,
30, 31, 32, 33, 34};
int checkIfVisited[5][5] = {0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0,
0,0,0,0,0};
int i,j,dir,countVisited;
dir = 0;
countVisited = 0;
i = 0;
j = 0;
while(countVisited<5*5)
{
cout<<arr[i][j]<<" ";
checkIfVisited[i][j]=1;
if(dir==0)
{
countVisited++;
if(i+1>4 || checkIfVisited[i+1][j]==1){
dir=1;
j++;
}
else
i++;
}
else if(dir==1)
{
countVisited++;
if(j+1>4 || checkIfVisited[i][j+1]==1){
dir=2;
i--;
}
else
j++;
}
else if(dir==2)
{
countVisited++;
if(i-1<0 || checkIfVisited[i-1][j]==1){
dir=3;
j--;
}
else
i--;
}
else
{
countVisited++;
if(j-1<0 || checkIfVisited[i][j-1]==1){
dir=0;
i++;
}
else
j--;
}
}
return 0;
}
Output: 10 15 20 25 30 31 32 33 34 29 24 19 14 13 12 11 16 21 26 27 28 23 18 17 22
