Open In App

# 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 ``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 v = ``new` `ArrayList();` `        ``// 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

 ``

Output:

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

Time Complexity: O(N2)
Auxiliary Space: O(1)