Spiral Pattern
Last Updated :
26 Aug, 2022
Given a number N, the task is to print the following pattern:
Examples:
Input : N = 4
Output : 4 4 4 4 4 4 4
4 3 3 3 3 3 4
4 3 2 2 2 3 4
4 3 2 1 2 3 4
4 3 2 2 2 3 4
4 3 3 3 3 3 4
4 4 4 4 4 4 4
Input : N = 2
Output : 2 2 2
2 1 2
2 2 2
Approach 1:
The common observation is that the square thus formed will be of size (2*N-1)x(2*N-1). Fill the first row and column, last row and column with N, and then gradually decrease N and fill the remaining rows and columns similarly. Decrease N every time after filling 2 rows and 2 columns.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void pattern( int value)
{
int row = 2 * value - 1;
int column = 2 * value - 1;
int arr[row][column];
int i, j, k;
for (k = 0; k < value; k++) {
j = k;
while (j < column - k) {
arr[k][j] = value - k;
j++;
}
i = k + 1;
while (i < row - k) {
arr[i][row - 1 - k] = value - k;
i++;
}
j = column - k - 2;
while (j >= k) {
arr[column - k - 1][j] = value - k;
j--;
}
i = row - k - 2;
while (i > k) {
arr[i][k] = value - k;
i--;
}
}
for (i = 0; i < row; i++) {
for (j = 0; j < column; j++) {
cout << arr[i][j] << " " ;
}
cout << endl;
}
}
int main()
{
int n = 5;
pattern(n);
return 0;
}
|
Java
class GFG {
static void pattern( int value)
{
int row = 2 * value - 1 ;
int column = 2 * value - 1 ;
int [][] arr = new int [row][column];
int i, j, k;
for (k = 0 ; k < value; k++) {
j = k;
while (j < column - k) {
arr[k][j] = value - k;
j++;
}
i = k + 1 ;
while (i < row - k) {
arr[i][row - 1 - k] = value - k;
i++;
}
j = column - k - 2 ;
while (j >= k) {
arr[column - k - 1 ][j] = value - k;
j--;
}
i = row - k - 2 ;
while (i > k) {
arr[i][k] = value - k;
i--;
}
}
for (i = 0 ; i < row; i++) {
for (j = 0 ; j < column; j++) {
System.out.print(arr[i][j] + " " );
}
System.out.println();
}
}
public static void main(String[] args)
{
int n = 5 ;
pattern(n);
}
}
|
Python3
def pattern(value):
row = 2 * value - 1
column = 2 * value - 1
arr = [[ 0 for i in range (row)]
for j in range (column)]
for k in range ( value):
j = k
while (j < column - k):
arr[k][j] = value - k
j + = 1
i = k + 1
while (i < row - k):
arr[i][row - 1 - k] = value - k
i + = 1
j = column - k - 2
while j > = k :
arr[column - k - 1 ][j] = value - k
j - = 1
i = row - k - 2
while i > k :
arr[i][k] = value - k
i - = 1
for i in range (row):
for j in range (column):
print (arr[i][j], end = " " )
print ()
if __name__ = = "__main__" :
n = 5
pattern(n)
|
C#
using System;
class GFG {
static void pattern( int value)
{
int row = 2 * value - 1;
int column = 2 * value - 1;
int [, ] arr = new int [row, column];
int i, j, k;
for (k = 0; k < value; k++) {
j = k;
while (j < column - k) {
arr[k, j] = value - k;
j++;
}
i = k + 1;
while (i < row - k) {
arr[i, row - 1 - k] = value - k;
i++;
}
j = column - k - 2;
while (j >= k) {
arr[column - k - 1, j] = value - k;
j--;
}
i = row - k - 2;
while (i > k) {
arr[i, k] = value - k;
i--;
}
}
for (i = 0; i < row; i++) {
for (j = 0; j < column; j++) {
Console.Write(arr[i, j] + " " );
}
Console.Write( "\n" );
}
}
public static void Main()
{
int n = 5;
pattern(n);
}
}
|
PHP
<?php
function pattern( $value )
{
$row = 2 * $value - 1;
$column = 2 * $value - 1;
$arr = array ( array ());
for ( $k = 0; $k < $value ; $k ++)
{
$j = $k ;
while ( $j < $column - $k )
{
$arr [ $k ][ $j ] = $value - $k ;
$j ++;
}
$i = $k + 1;
while ( $i < $row - $k )
{
$arr [ $i ][ $row - 1 - $k ] = $value - $k ;
$i ++;
}
$j = $column - $k - 2;
while ( $j >= $k )
{
$arr [ $column - $k - 1][ $j ] = $value - $k ;
$j --;
}
$i = $row - $k - 2;
while ( $i > $k )
{
$arr [ $i ][ $k ] = $value - $k ;
$i --;
}
}
for ( $i = 0; $i < $row ; $i ++)
{
for ( $j = 0; $j < $column ; $j ++)
{
echo $arr [ $i ][ $j ] . " " ;
}
echo "\n" ;
}
}
$n = 5;
pattern( $n );
?>
|
Javascript
<script>
function pattern(value)
{
let row = 2 * value - 1;
let column = 2 * value - 1;
let arr = new Array(row);
for (let i = 0; i < row; i++)
{
arr[i] = new Array(column);
}
let i, j, k;
for (k = 0; k < value; k++)
{
j = k;
while (j < column - k)
{
arr[k][j] = value - k;
j++;
}
i = k + 1;
while (i < row - k)
{
arr[i][row - 1 - k] = value - k;
i++;
}
j = column - k - 2;
while (j >= k)
{
arr[column - k - 1][j] = value - k;
j--;
}
i = row - k - 2;
while (i > k)
{
arr[i][k] = value - k;
i--;
}
}
for (i = 0; i < row; i++)
{
for (j = 0; j < column; j++)
{
document.write(arr[i][j] + " " );
}
document.write( "<br>" );
}
}
let n = 5;
pattern(n);
</script>
|
Output
5 5 5 5 5 5 5 5 5
5 4 4 4 4 4 4 4 5
5 4 3 3 3 3 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 2 1 2 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 3 3 3 3 4 5
5 4 4 4 4 4 4 4 5
5 5 5 5 5 5 5 5 5
Approach 2: Starting the indexing from i = 1 and j = 1, it can be observed that every value of the required matrix will be max(abs(i – n), abs(j – n)) + 1.
Below is the implementation of the above approach:
C++14
#include <algorithm>
#include <iostream>
using namespace std;
void pattern( int n)
{
int p = 2 * n - 1;
for ( int i = 1; i <= p; i++) {
for ( int j = 1; j <= p; j++) {
cout << max( abs (i - n), abs (j - n)) + 1 << " " ;
}
cout << endl;
}
}
int main()
{
int n = 5;
pattern(n);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
int max( int , int );
void pattern( int n)
{
int size = 2 * n - 1;
for ( int i = 1; i <= size; i++)
{
for ( int j = 1; j <= size; j++)
{
printf ( "%d " , max( abs (i - n),
abs (j - n)) + 1);
}
printf ( "\n" );
}
}
int max( int val1, int val2)
{
if (val1 > val2)
return val1;
return val2;
}
int main()
{
int n = 5;
pattern(n);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
public static void pattern( int n)
{
int size = 2 * n - 1 ;
for ( int i = 1 ; i <= size; i++)
{
for ( int j = 1 ; j <= size; j++)
{
System.out.print(Math.max(
Math.abs(i - n),
Math.abs(j - n)) + 1 + " " );
}
System.out.println();
}
}
public static void main(String[] args)
{
int n = 5 ;
pattern(n);
}
}
|
Python3
def pattern(n):
p = 2 * n - 1
for i in range ( 1 , p + 1 ):
for j in range ( 1 , p + 1 ):
print ( max ( abs (i - n), abs (j - n)) + 1 , " " , end = "")
print ()
n = 5
pattern(n)
|
C#
using System;
class GFG{
static void pattern( int n)
{
int size = 2 * n - 1;
for ( int i = 1; i <= size; i++)
{
for ( int j = 1; j <= size; j++)
{
Console.Write(Math.Max(Math.Abs(i - n),
Math.Abs(j - n)) +
1 + " " );
}
Console.WriteLine();
}
}
public static void Main()
{
int n = 5;
pattern(n);
}
}
|
Javascript
<script>
function pattern(n)
{
let p = 2 * n - 1;
for (let i = 1; i <= p; i++) {
for (let j = 1; j <= p; j++) {
document.write((Math.max(Math.abs(i - n),
Math.abs(j - n)) + 1) + " " );
}
document.write( "<br>" );
}
}
let n = 5;
pattern(n);
</script>
|
Output
5 5 5 5 5 5 5 5 5
5 4 4 4 4 4 4 4 5
5 4 3 3 3 3 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 2 1 2 3 4 5
5 4 3 2 2 2 3 4 5
5 4 3 3 3 3 3 4 5
5 4 4 4 4 4 4 4 5
5 5 5 5 5 5 5 5 5
Complexity Analysis:
- Time complexity: O(n^2) for given n.
- Auxiliary space : O(1)
Share your thoughts in the comments
Please Login to comment...