Construct a square Matrix using digits of given number N based on given pattern

Given an integer N, The task is to construct a matrix mat[][] of size M x M (‘M’ is the number of digits in the given integer) such that each diagonal of the matrix contains the same digit, placed according to the position of the digits in the given integer and then again repeat the steps from the back.

Examples:

Input: N = 123
Output: {{1, 2, 3}, 
               {2, 3, 2}, 
               {3, 2, 1}}
Explanation: The desired matrix must be of size 3*3. The digits of N are 1, 2, and 3. Placing 1, 2 and 3 along the diagonals from the top left cell till the Nth diagonal, and 2, 1 just after the Nth diagonal till the bottom-most cell.

Input: N = 3219
Output: {{3, 2, 1, 9}, {2, 1, 9, 1}, {1, 9, 1, 2}, {9, 1, 2, 3}}

Approach: The task can be solved by traversing the matrix in a diagonal fashion and assigning the cell values according to the corresponding digit in the given number.

1. Extract and store the digits of the given integer in a vector say v.
2. Again store the digits in reverse order for 2nd half diagonal of the matrix.
3. Assign the digits in the desired order.
4. Print the matrix.

Below is the implementation of the above approach: 

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to construct the matrix
void constructMatrix(int n)
{
    // Vector to store the
    // digits of the integer
    vector<int> v;

    // Extracting the digits
    // from the integer
    while (n > 0) {
        v.push_back(n % 10);
        n = n / 10;
    }

    // Reverse the vector
    reverse(v.begin(), v.end());

    // Size of the vector
    int N = v.size();

    // Loop to store the digits in
    // reverse order in the same vector
    for (int i = N - 2; i >= 0; i--) {
        v.push_back(v[i]);
    }

    // Matrix to be constructed
    int mat[N][N];

    // Assign the digits and
    // print the desired matrix
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            mat[i][j] = v[i + j];
            cout << mat[i][j] << " ";
        }
        cout << endl;
    }
}

// Driver Code
int main()
{
    int n = 3219;

    // Passing n to constructMatrix function
    constructMatrix(n);

    return 0;
}

Java

// Java program for the above approach

import java.util.ArrayList;
import java.util.Collections;

class GFG {

    // Function to construct the matrix
    public static void constructMatrix(int n)
    {

        // Vector to store the
        // digits of the integer
        ArrayList<Integer> v = new ArrayList<Integer>();

        // Extracting the digits
        // from the integer
        while (n > 0) {
            v.add(n % 10);
            n = n / 10;
        }

        // Reverse the vector
        Collections.reverse(v);

        // Size of the vector
        int N = v.size();

        // Loop to store the digits in
        // reverse order in the same vector
        for (int i = N - 2; i >= 0; i--) {
            v.add(v.get(i));
        }

        // Matrix to be constructed
        int[][] mat = new int[N][N];

        // Assign the digits and
        // print the desired matrix
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                mat[i][j] = v.get(i + j);
                System.out.print(mat[i][j] + " ");
            }
            System.out.println("");
        }
    }

    // Driver Code
    public static void main(String args[]) {
        int n = 3219;

        // Passing n to constructMatrix function
        constructMatrix(n);
    }
}

// This code is contributed by gfgking.

Python3

# python program for the above approach

# Function to construct the matrix
def constructMatrix(n):

    # Vector to store the
    # digits of the integer
    v = []

    # Extracting the digits
    # from the integer
    while (n > 0):
        v.append(n % 10)
        n = n // 10

    # Reverse the vector
    v.reverse()

    # Size of the vector
    N = len(v)

    # Loop to store the digits in
    # reverse order in the same vector
    for i in range(N-2, -1, -1):
        v.append(v[i])

    # Matrix to be constructed
    mat = [[0 for _ in range(N)] for _ in range(N)]

    # Assign the digits and
    # print the desired matrix
    for i in range(0, N):
        for j in range(0, N):
            mat[i][j] = v[i + j]
            print(mat[i][j], end=" ")

        print()

# Driver Code
if __name__ == "__main__":
    n = 3219

    # Passing n to constructMatrix function
    constructMatrix(n)

# This code is contributed by rakeshsahni

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to construct the matrix
static void constructMatrix(int n)
{

    // Vector to store the
    // digits of the integer
    List<int> v = new List<int>();

    // Extracting the digits
    // from the integer
    while (n > 0) {
        v.Add(n % 10);
        n = n / 10;
    }

    // Reverse the vector
    v.Reverse();

    // Size of the vector
    int N = v.Count;

    // Loop to store the digits in
    // reverse order in the same vector
    for (int i = N - 2; i >= 0; i--) {
        v.Add(v[i]);
    }

    // Matrix to be constructed
    int[,] mat = new int[N, N];

    // Assign the digits and
    // print the desired matrix
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            mat[i, j] = v[i + j];
            Console.Write(mat[i, j] + " ");
        }
        Console.WriteLine();
    }
}


// Driver Code
public static void Main()
{
    int n = 3219;

    // Passing n to constructMatrix function
    constructMatrix(n);
}
}

// This code is contributed by sanjoy_62.

Javascript

<script>
       // JavaScript Program to implement
       // the above approach

       // Function to construct the matrix
       function constructMatrix(n)
       {

           // Vector to store the
           // digits of the integer
           let v = [];

           // Extracting the digits
           // from the integer
           while (n > 0) {
               v.push(n % 10);
               n = Math.floor(n / 10);
           }

           // Reverse the vector
           v.reverse();

           // Size of the vector
           let N = v.length;

           // Loop to store the digits in
           // reverse order in the same vector
           for (let i = N - 2; i >= 0; i--) {
               v.push(v[i]);
           }

           // Matrix to be constructed
           let mat = new Array(N);
           for (let i = 0; i < mat.length; i++) {
               mat[i] = new Array(N).fill(0);
           }

           // Assign the digits and
           // print the desired matrix
           for (let i = 0; i < N; i++) {
               for (let j = 0; j < N; j++) {
                   mat[i][j] = v[i + j];
                   document.write(mat[i][j] + " ");
               }
               document.write("<br>")
           }
       }

       // Driver Code
       let n = 3219;

       // Passing n to constructMatrix function
       constructMatrix(n);

   // This code is contributed by Potta Lokesh
   </script>

Output:

3 2 1 9 
2 1 9 1 
1 9 1 2 
9 1 2 3

Time Complexity: O(N²)
Auxiliary Space: O(1)