Given a number n as the size of the matrix, the task is to print a spiral pattern in 2D array of size n.
Examples:
Input: n = 5 Output: 1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9
Preview of the Spiral Pattern:
Approach:
- Create a 2D array of size n
- Store the boundary of the array in boundary variable. Initially it will be n-1 and thereafter it changes after every rotation.
- Store the size left for the spiral printing in variable sizeLeft. Initially it will be n-1 and thereafter it will decrease by 1 after every 2 rotations.
- Create a flag to determine 2 rotations, as after every 2 rotations, the sizeLeft will decrease.
- Create a char variable move to store the current movement of the spiral pattern. It can have ‘r’ for right, ‘l’ for left, ‘d’ for down, and ‘u’ for up.
- Repeat the below steps till ‘i’ is in range [1, n^2]:
- Assign the value of i to the spiral pattern.
- Determine the next movement of the pattern.
- Check for pattern to reach boundary. If reached, modify the sizes and rotate the spiral pattern.
- Print the Spiral Pattern stored in the 2D array.
Below is Java implementation of the above approach:
C++
#include <iostream> using namespace std;
void printSpiral( int size)
{ // Create row and col
// to traverse rows and columns
int row = 0, col = 0;
int boundary = size - 1;
int sizeLeft = size - 1;
int flag = 1;
// Variable to determine the movement
// r = right, l = left, d = down, u = upper
char move = 'r' ;
// Array for matrix
int matrix[size][size] = {0};
for ( int i = 1; i < size * size + 1; i++)
{
// Assign the value
matrix[row][col] = i;
// switch-case to determine the next index
switch (move)
{
// If right, go right
case 'r' :
col += 1;
break ;
// if left, go left
case 'l' :
col -= 1;
break ;
// if up, go up
case 'u' :
row -= 1;
break ;
// if down, go down
case 'd' :
row += 1;
break ;
}
// Check if the matrix
// has reached array boundary
if (i == boundary)
{
// Add the left size for the next boundary
boundary += sizeLeft;
// If 2 rotations has been made,
// decrease the size left by 1
if (flag != 2)
{
flag = 2;
}
else
{
flag = 1;
sizeLeft -= 1;
}
// switch-case to rotate the movement
switch (move)
{
// if right, rotate to down
case 'r' :
move = 'd' ;
break ;
// if down, rotate to left
case 'd' :
move = 'l' ;
break ;
// if left, rotate to up
case 'l' :
move = 'u' ;
break ;
// if up, rotate to right
case 'u' :
move = 'r' ;
break ;
}
}
}
// Print the matrix
for (row = 0; row < size; row++)
{
for (col = 0; col < size; col++)
{
int n = matrix[row][col];
if (n < 10)
cout << n << " " ;
else
cout << n << " " ;
}
cout << endl;
}
} // Driver Code int main()
{ // Get the size of size
int size = 5;
// Print the Spiral Pattern
printSpiral(size);
return 0;
} // This code is contributed by 29AjayKumar |
Java
public class GFG {
public static void printSpiral( int size)
{
// Create row and col
// to traverse rows and columns
int row = 0 , col = 0 ;
int boundary = size - 1 ;
int sizeLeft = size - 1 ;
int flag = 1 ;
// Variable to determine the movement
// r = right, l = left, d = down, u = upper
char move = 'r' ;
// Array for matrix
int matrix[][] = new int [size][size];
for ( int i = 1 ; i < size * size + 1 ; i++) {
// Assign the value
matrix[row][col] = i;
// switch-case to determine the next index
switch (move) {
// If right, go right
case 'r' :
col += 1 ;
break ;
// if left, go left
case 'l' :
col -= 1 ;
break ;
// if up, go up
case 'u' :
row -= 1 ;
break ;
// if down, go down
case 'd' :
row += 1 ;
break ;
}
// Check if the matrix
// has reached array boundary
if (i == boundary) {
// Add the left size for the next boundary
boundary += sizeLeft;
// If 2 rotations has been made,
// decrease the size left by 1
if (flag != 2 ) {
flag = 2 ;
}
else {
flag = 1 ;
sizeLeft -= 1 ;
}
// switch-case to rotate the movement
switch (move) {
// if right, rotate to down
case 'r' :
move = 'd' ;
break ;
// if down, rotate to left
case 'd' :
move = 'l' ;
break ;
// if left, rotate to up
case 'l' :
move = 'u' ;
break ;
// if up, rotate to right
case 'u' :
move = 'r' ;
break ;
}
}
}
// Print the matrix
for (row = 0 ; row < size; row++) {
for (col = 0 ; col < size; col++) {
int n = matrix[row][col];
System.out.print((n < 10 )
? (n + " " )
: (n + " " ));
}
System.out.println();
}
}
// Driver Code
public static void main(String[] args)
{
// Get the size of size
int size = 5 ;
// Print the Spiral Pattern
printSpiral(size);
}
} |
Python3
def printSpiral(size):
# Create row and col to traverse rows and columns
row, col = 0 , 0
boundary = size - 1
sizeLeft = size - 1
flag = 1
# Variable to determine the movement
# r = right, l = left, d = down, u = upper
move = 'r'
# Array for matrix
matrix = [[ 0 for j in range (size)] for i in range (size)]
for i in range ( 1 , size * size + 1 ):
# Assign the value
matrix[row][col] = i
# switch-case to determine the next index
if move = = 'r' :
col + = 1
elif move = = 'l' :
col - = 1
elif move = = 'u' :
row - = 1
elif move = = 'd' :
row + = 1
# Check if the matrix has reached array boundary
if i = = boundary:
# Add the left size for the next boundary
boundary + = sizeLeft
# If 2 rotations have been made,
# decrease the size left by 1
if flag ! = 2 :
flag = 2
else :
flag = 1
sizeLeft - = 1
# switch-case to rotate the movement
if move = = 'r' :
move = 'd'
elif move = = 'd' :
move = 'l'
elif move = = 'l' :
move = 'u'
elif move = = 'u' :
move = 'r'
# Print the matrix
for row in range (size):
for col in range (size):
n = matrix[row][col]
print (n, end = ' ' if n < 10 else ' ' )
print ()
# Driver Code size = 5
# Print the Spiral Pattern printSpiral(size) |
C#
// C# implementation of the approach using System;
class GFG {
public static void printSpiral( int size)
{
// Create row and col
// to traverse rows and columns
int row = 0, col = 0;
int boundary = size - 1;
int sizeLeft = size - 1;
int flag = 1;
// Variable to determine the movement
// r = right, l = left, d = down, u = upper
char move = 'r' ;
// Array for matrix
int [, ] matrix = new int [size, size];
for ( int i = 1; i < size * size + 1; i++) {
// Assign the value
matrix[row, col] = i;
// switch-case to determine the next index
switch (move) {
// If right, go right
case 'r' :
col += 1;
break ;
// if left, go left
case 'l' :
col -= 1;
break ;
// if up, go up
case 'u' :
row -= 1;
break ;
// if down, go down
case 'd' :
row += 1;
break ;
}
// Check if the matrix
// has reached array boundary
if (i == boundary) {
// Add the left size for the next boundary
boundary += sizeLeft;
// If 2 rotations has been made,
// decrease the size left by 1
if (flag != 2) {
flag = 2;
}
else {
flag = 1;
sizeLeft -= 1;
}
// switch-case to rotate the movement
switch (move) {
// if right, rotate to down
case 'r' :
move = 'd' ;
break ;
// if down, rotate to left
case 'd' :
move = 'l' ;
break ;
// if left, rotate to up
case 'l' :
move = 'u' ;
break ;
// if up, rotate to right
case 'u' :
move = 'r' ;
break ;
}
}
}
// Print the matrix
for (row = 0; row < size; row++) {
for (col = 0; col < size; col++) {
int n = matrix[row, col];
Console.Write((n < 10)
? (n + " " )
: (n + " " ));
}
Console.WriteLine();
}
}
// Driver Code
public static void Main(String[] args)
{
// Get the size of size
int size = 5;
// Print the Spiral Pattern
printSpiral(size);
}
} /* This code contributed by PrinciRaj1992 */ |
Javascript
<script> function printSpiral(size)
{ // Create row and col
// to traverse rows and columns
let row = 0, col = 0;
let boundary = size - 1;
let sizeLeft = size - 1;
let flag = 1;
// Variable to determine the movement
// r = right, l = left, d = down, u = upper
let move = 'r' ;
// Array for matrix
let matrix = new Array(size);
for (let i = 0; i < size; i++)
{
matrix[i] = new Array(size).fill(0);
}
for (let i = 1; i < size * size + 1; i++)
{
// Assign the value
matrix[row][col] = i;
// switch-case to determine
// the next index
switch (move)
{
// If right, go right
case 'r' :
col += 1;
break ;
// If left, go left
case 'l' :
col -= 1;
break ;
// If up, go up
case 'u' :
row -= 1;
break ;
// If down, go down
case 'd' :
row += 1;
break ;
}
// Check if the matrix
// has reached array boundary
if (i == boundary)
{
// Add the left size for the
// next boundary
boundary += sizeLeft;
// If 2 rotations has been made,
// decrease the size left by 1
if (flag != 2)
{
flag = 2;
}
else
{
flag = 1;
sizeLeft -= 1;
}
// switch-case to rotate the movement
switch (move)
{
// If right, rotate to down
case 'r' :
move = 'd' ;
break ;
// If down, rotate to left
case 'd' :
move = 'l' ;
break ;
// If left, rotate to up
case 'l' :
move = 'u' ;
break ;
// If up, rotate to right
case 'u' :
move = 'r' ;
break ;
}
}
}
// Print the matrix
for (row = 0; row < size; row++)
{
for (col = 0; col < size; col++)
{
let n = matrix[row][col];
if (n < 10)
document.write(n + " " );
else
document.write(n + " " );
}
document.write( "<br>" );
}
} // Driver Code // Get the size of size let size = 5; // Print the Spiral Pattern printSpiral(size); // This code is contributed by subham348 </script> |
Output
1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9
Complexity Analysis:
- Time complexity: O(m*n) where m is number of rows and n is number of columns of a given matrix
- Auxiliary Space: O(1) because constant space has been used
Recommended Articles