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

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.
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)

This article is contributed by Ayush Jauhari. 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.