Open In App
Related Articles

Circular Matrix (Construct a matrix with numbers 1 to m*n in spiral way)

Improve Article
Improve
Save Article
Save
Like Article
Like

Given two values m and n, fill a matrix of size ‘m*n’ in a spiral (or circular) fashion (clockwise) with natural numbers from 1 to m*n.

Examples:  

Input : m = 4, n = 4
Output :  1  2  3  4
         12 13 14  5
         11 16 15  6
         10  9  8  7 

Input : m = 3, n = 4
Output :  1  2  3  4
          10 11 12 5
          9  8  7  6     

The idea is based on Print a given matrix in spiral form. We create a matrix of size m * n and traverse it in a spiral fashion. While traversing, we keep track of a variable “val” to fill the next value, we increment “val” one by one and put its values in the matrix. 

Implementation:

C++




// C++ program to fill a matrix with values from
// 1 to n*n in spiral fashion.
#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 100;
 
// Fills a[m][n] with values from 1 to m*n in
// spiral fashion.
void spiralFill(int m, int n, int a[][MAX])
{
    // Initialize value to be filled in matrix
    int val = 1;
 
    /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index */
    int k = 0, l = 0;
    while (k < m && l < n)
    {
        /* Print the first row from the remaining
          rows */
        for (int i = l; i < n; ++i)
            a[k][i] = val++;
 
        k++;
 
        /* Print the last column from the remaining
          columns */
        for (int i = k; i < m; ++i)
            a[i][n-1] = val++;
        n--;
 
        /* Print the last row from the remaining
           rows */
        if (k < m)
        {
            for (int i = n-1; i >= l; --i)
                a[m-1][i] = val++;
            m--;
        }
 
        /* Print the first column from the remaining
           columns */
        if (l < n)
        {
            for (int i = m-1; i >= k; --i)
                 a[i][l] = val++;
            l++;
        }
    }
}
 
/* Driver program to test above functions */
int main()
{
    int m = 4, n = 4;
    int a[MAX][MAX];
    spiralFill(m, n, a);
    for (int i=0; i<m; i++)
    {
       for (int j=0; j<n; j++)
          cout << a[i][j] << " ";
       cout << endl;
    }
    return 0;
}


C




// C program to fill a matrix with values from
// 1 to n*n in spiral fashion.
#include <stdio.h>
 
const int MAX = 100;
 
// Fills a[m][n] with values from 1 to m*n in
// spiral fashion.
void spiralFill(int m, int n, int a[][MAX])
{
    // Initialize value to be filled in matrix
    int val = 1;
 
    /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index */
    int k = 0, l = 0;
    while (k < m && l < n)
    {
        /* Print the first row from the remaining
          rows */
        for (int i = l; i < n; ++i)
            a[k][i] = val++;
 
        k++;
 
        /* Print the last column from the remaining
          columns */
        for (int i = k; i < m; ++i)
            a[i][n-1] = val++;
        n--;
 
        /* Print the last row from the remaining
           rows */
        if (k < m)
        {
            for (int i = n-1; i >= l; --i)
                a[m-1][i] = val++;
            m--;
        }
 
        /* Print the first column from the remaining
           columns */
        if (l < n)
        {
            for (int i = m-1; i >= k; --i)
                 a[i][l] = val++;
            l++;
        }
    }
}
 
/* Driver program to test above functions */
int main()
{
    int m = 4, n = 4;
    int a[MAX][MAX];
    spiralFill(m, n, a);
    for (int i=0; i<m; i++)
    {
       for (int j=0; j<n; j++)
          printf("%d ",a[i][j]);
       printf("\n");
    }
    return 0;
}
 
// This code is contributed by kothavvsaakash.


Java




// Java program to fill a matrix with values from
// 1 to n*n in spiral fashion.
import java.io.*;
class GFG {
 
    static int MAX = 100;
 
// Fills a[m][n] with values from 1 to m*n in
// spiral fashion.
    static void spiralFill(int m, int n, int a[][]) {
        // Initialize value to be filled in matrix
        int val = 1;
 
        /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index */
        int k = 0, l = 0;
        while (k < m && l < n) {
            /* Print the first row from the remaining
          rows */
            for (int i = l; i < n; ++i) {
                a[k][i] = val++;
            }
 
            k++;
 
            /* Print the last column from the remaining
          columns */
            for (int i = k; i < m; ++i) {
                a[i][n - 1] = val++;
            }
            n--;
 
            /* Print the last row from the remaining
           rows */
            if (k < m) {
                for (int i = n - 1; i >= l; --i) {
                    a[m - 1][i] = val++;
                }
                m--;
            }
 
            /* Print the first column from the remaining
           columns */
            if (l < n) {
                for (int i = m - 1; i >= k; --i) {
                    a[i][l] = val++;
                }
                l++;
            }
        }
    }
 
    /* Driver program to test above functions */
    public static void main(String[] args) {
        int m = 4, n = 4;
        int a[][] = new int[MAX][MAX];
        spiralFill(m, n, a);
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(a[i][j] + " ");
            }
            System.out.println("");
        }
    }
}
 
/* This Java code is contributed by PrinciRaj1992*/


Python3




# Python program to fill a matrix with
# values from 1 to n*n in spiral fashion.
 
# Fills a[m][n] with values
# from 1 to m*n in spiral fashion.
def spiralFill(m, n, a):
 
    # Initialize value to be filled in matrix.
    val = 1
 
    # k - starting row index
    # m - ending row index
    # l - starting column index
    # n - ending column index
    k, l = 0, 0
    while (k < m and l < n):
 
        # Print the first row from the remaining rows.
        for i in range(l, n):
            a[k][i] = val
            val += 1
        k += 1
 
        # Print the last column from the remaining columns.
        for i in range(k, m):
            a[i][n - 1] = val
            val += 1
        n -= 1
 
        # Print the last row from the remaining rows.
        if (k < m):
            for i in range(n - 1, l - 1, -1):
                a[m - 1][i] = val
                val += 1
            m -= 1
 
        # Print the first column from the remaining columns.
        if (l < n):
            for i in range(m - 1, k - 1, -1):
                a[i][l] = val
                val += 1
            l += 1
 
# Driver program
if __name__ == '__main__':
    m, n = 4, 4
    a = [[0 for j in range(n)] for i in range(m)]
    spiralFill(m, n, a)
    for i in range(m):
        for j in range(n):
            print(a[i][j], end=' ')
        print('')
 
# This code is contributed by Parin Shah


C#




// C# program to fill a matrix with values from
// 1 to n*n in spiral fashion.
 
using System;
class GFG {
  
    static int MAX = 100;
  
// Fills a[m,n] with values from 1 to m*n in
// spiral fashion.
    static void spiralFill(int m, int n, int[,] a) {
        // Initialize value to be filled in matrix
        int val = 1;
  
        /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index */
        int k = 0, l = 0;
        while (k < m && l < n) {
            /* Print the first row from the remaining
          rows */
            for (int i = l; i < n; ++i) {
                a[k,i] = val++;
            }
  
            k++;
  
            /* Print the last column from the remaining
          columns */
            for (int i = k; i < m; ++i) {
                a[i,n - 1] = val++;
            }
            n--;
  
            /* Print the last row from the remaining
           rows */
            if (k < m) {
                for (int i = n - 1; i >= l; --i) {
                    a[m - 1,i] = val++;
                }
                m--;
            }
  
            /* Print the first column from the remaining
           columns */
            if (l < n) {
                for (int i = m - 1; i >= k; --i) {
                    a[i,l] = val++;
                }
                l++;
            }
        }
    }
  
    /* Driver program to test above functions */
    public static void Main() {
        int m = 4, n = 4;
        int[,] a = new int[MAX,MAX];
        spiralFill(m, n, a);
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                Console.Write(a[i,j] + " ");
            }
            Console.Write("\n");
        }
    }
}


PHP




<?php
// PHP program to fill a matrix with values
// from 1 to n*n in spiral fashion.
 
// Fills a[m][n] with values from 1 to
// m*n in spiral fashion.
function spiralFill($m, $n, &$a)
{
    // Initialize value to be filled
    // in matrix
    $val = 1;
 
    /* k - starting row index
       m - ending row index
       l - starting column index
       n - ending column index */
    $k = 0;
    $l = 0;
    while ($k < $m && $l < $n)
    {
        /* Print the first row from
        the remaining rows */
        for ($i = $l; $i < $n; ++$i)
            $a[$k][$i] = $val++;
 
        $k++;
 
        /* Print the last column from
        the remaining columns */
        for ($i = $k; $i < $m; ++$i)
            $a[$i][$n - 1] = $val++;
        $n--;
 
        /* Print the last row from
        the remaining rows */
        if ($k < $m)
        {
            for ($i = $n - 1; $i >= $l; --$i)
                $a[$m - 1][$i] = $val++;
            $m--;
        }
 
        /* Print the first column from
           the remaining columns */
        if ($l < $n)
        {
            for ($i = $m - 1; $i >= $k; --$i)
                $a[$i][$l] = $val++;
            $l++;
        }
    }
}
 
// Driver Code
$m = 4;
$n = 4;
spiralFill($m, $n, $a);
for ($i = 0; $i < $m; $i++)
{
    for ($j = 0; $j < $n; $j++)
    {
        echo ($a[$i][$j]);
        echo (" ");
    }
    echo ("\n");
}
 
// This code is contributed
// by Shivi_Aggarwal
?>


Javascript




<script>
// Javascript program to fill a matrix with values from
// 1 to n*n in spiral fashion.
 
const MAX = 100;
 
// Fills a[m][n] with values from 1 to m*n in
// spiral fashion.
function spiralFill(m, n, a)
{
    // Initialize value to be filled in matrix
    let val = 1;
 
    /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index */
    let k = 0, l = 0;
    while (k < m && l < n)
    {
        /* Print the first row from the remaining
          rows */
        for (let i = l; i < n; ++i)
            a[k][i] = val++;
 
        k++;
 
        /* Print the last column from the remaining
          columns */
        for (let i = k; i < m; ++i)
            a[i][n-1] = val++;
        n--;
 
        /* Print the last row from the remaining
           rows */
        if (k < m)
        {
            for (let i = n - 1; i >= l; --i)
                a[m-1][i] = val++;
            m--;
        }
 
        /* Print the first column from the remaining
           columns */
        if (l < n)
        {
            for (let i = m - 1; i >= k; --i)
                 a[i][l] = val++;
            l++;
        }
    }
}
 
/* Driver program to test above functions */
    let m = 4, n = 4;
    let a = Array.from(Array(MAX), () => new Array(MAX));
    spiralFill(m, n, a);
    for (let i = 0; i < m; i++)
    {
       for (let j = 0; j < n; j++)
          document.write(a[i][j] + " ");
       document.write("<br>");
    }
 
// This code is contributed by souravmahato348.
</script>


Output

1 2 3 4 
12 13 14 5 
11 16 15 6 
10 9 8 7 

Time Complexity: O(m * n) 
Space Complexity: O(m * n)

If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 12 Dec, 2022
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials