Related Articles

# Fill an empty 2D Matrix with integers from 1 to N*N filled diagonally

• Difficulty Level : Medium
• Last Updated : 06 Sep, 2021

Given an integer N, the task is to fill a matrix M of size NxN, starting from the main diagonal and then alternating between the lower and upper triangular diagonals, in an increasing fashion such that each number from 1 to N2 appears only once.

Examples:

```Input: N = 4
Output:
1 8 13 16
5 2 9 14
11 6 3 10
15 12 7 4
Explanation:
First filling the main diagonal:
1
2
3
4
Next, fill the lower diagonal below the main diagonal
1
5  2
6  3
7  4
Next, fill the upper diagonal above the main diagonal
1  8
5  2  9
6  3 10
7  4
Following the same pattern and altering between
upper and lower triangular matrix,
we get the final matrix as
1  8 13 16
5  2  9 14
11  6  3 10
15 12  7  4

Input: N = 3
Output:
1 6 9
4 2 7
8 5 3```

Approach: Follow the below steps to solve the problem:

• Initialize a variable cur to 1. This will keep track of the current number
• Initialize a variable d to 1. This keeps track of the diagonals.
• Iterate from 1 to (N+N-1) using d. This is the number of diagonals.
• If d is even, initialize two variables r and c to d/2 and 0 respectively.
• Otherwise, initialize the two variables r and c to 0 and d/2 respectively.
• Iterate till r and c both are less than N
• Update the matrix M as M[r]=cur.
• Increment cur, r, and c.
• After exiting the inner loop, increment d.
• Finally, display the matrix M.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;``// Function to fill the matrix diagonally alternating``// between upper and lower diagonals``void` `fillMatrix(``int` `N)``{``    ``// variables to keep track of``    ``// diagonals and current number``    ``int` `d = 1, cur = 1;``    ``// Matrix``    ``int` `M[N][N];``    ``// Iterating over all diagonals``    ``while` `(d <= 2 * N - 1) {``        ``int` `r, c;``        ``// For lower triangle``        ``if` `(d % 2 == 0)``            ``r = d / 2, c = 0;``        ``// For upper triangle``        ``else``            ``r = 0, c = d / 2;``        ``// Placing the current number``        ``// in appropriate position``        ``while` `(r < N && c < N) {``            ``M[r] = cur;``            ``cur++;``            ``r++;``            ``c++;``        ``}``        ``d++;``    ``}` `    ``// Displaying the matrix``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``cout << M[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``}``// Driver code``int` `main()``{``    ``// Input``    ``int` `N = 4;` `    ``// Function calling``    ``fillMatrix(N);``    ``return` `0;``}`

## Java

 `// Java implementation of the above approach` `import` `java.io.*;` `class` `GFG {``    ``static` `void` `fillmatrix(``int` `m[][], ``int` `n)``    ``{` `        ``int` `r, c;``        ``int` `num = ``1``, d = ``1``;``        ``// 2*n-1 is no of diagonals``        ``while` `(d <= ``2` `* n - ``1``) {``            ``// If d%2==0 switch to``            ``// lower triangular diagonal``            ``if` `(d % ``2` `== ``0``) {``                ``r = d / ``2``;``                ``c = ``0``;``                ``while` `(r < n && c < n) {``                    ``m[r] = num++;``                    ``r++;``                    ``c++;``                ``}``            ``}``            ``// If d%2==1 switch to``            ``// upper triangular diagonal``            ``else` `{``                ``r = ``0``;``                ``c = d / ``2``;``                ``while` `(c < n && r < n) {``                    ``m[r] = num++;``                    ``r++;``                    ``c++;``                ``}``            ``}``            ``d++;``        ``}``    ``}``    ``// Utility function to display the matrix``    ``static` `void` `display(``int` `m[][], ``int` `n)``    ``{``        ``int` `i, j;``        ``for` `(i = ``0``; i < n; i++) {``            ``for` `(j = ``0``; j < n; j++) {``                ``System.out.printf(m[i][j] + ``" "``);``            ``}``            ``System.out.println();``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``4``;``        ``int``[][] m = ``new` `int``[``4``][``4``];``        ``fillmatrix(m, n);``        ``display(m, n);``    ``}``}`

## Python3

 `# Python3 implementation of the above approach` `# Function to fill the matrix diagonally``# alternating between upper and lower diagonals``def` `fillMatrix(N):``    ` `    ``# Variables to keep track of``    ``# diagonals and current number``    ``d ``=` `1``    ``cur ``=` `1``    ` `    ``# Matrix``    ``M ``=` `[[``0` `for` `i ``in` `range``(N)]``            ``for` `i ``in` `range``(N)]``            ` `    ``# Iterating over all diagonals``    ``while` `(d <``=` `2` `*` `N ``-` `1``):``        ``r, c ``=` `0``, ``0``        ` `        ``# For lower triangle``        ``if` `(d ``%` `2` `=``=` `0``):``            ``r ``=` `d ``/``/` `2``            ``c ``=` `0``            ` `        ``# For upper triangle``        ``else``:``            ``r ``=` `0``            ``c ``=` `d ``/``/` `2``            ` `        ``# Placing the current number``        ``# in appropriate position``        ``while` `(r < N ``and` `c < N):``            ``M[r] ``=` `cur``            ``cur ``+``=` `1``            ``r ``+``=` `1``            ``c ``+``=` `1` `        ``d ``+``=` `1` `    ``# Displaying the matrix``    ``for` `i ``in` `M:``        ``print``(``*``i)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Input``    ``N ``=` `4` `    ``# Function calling``    ``fillMatrix(N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the above approach``using` `System.IO;``using` `System;` `class` `GFG{``    ` `static` `void` `fillmatrix(``int``[, ] m, ``int` `n)``{``    ``int` `r, c;``    ``int` `num = 1, d = 1;``    ` `    ``// 2*n-1 is no of diagonals``    ``while` `(d <= 2 * n - 1)``    ``{``        ` `        ``// If d%2==0 switch to``        ``// lower triangular diagonal``        ``if` `(d % 2 == 0)``        ``{``            ``r = d / 2;``            ``c = 0;``            ``while` `(r < n && c < n)``            ``{``                ``m[r, c] = num++;``                ``r++;``                ``c++;``            ``}``        ``}``        ` `        ``// If d%2==1 switch to``        ``// upper triangular diagonal``        ``else``        ``{``            ``r = 0;``            ``c = d / 2;``            ` `            ``while` `(c < n && r < n)``            ``{``                ``m[r, c] = num++;``                ``r++;``                ``c++;``            ``}``        ``}``        ``d++;``    ``}``}` `// Utility function to display the matrix``static` `void` `display(``int``[,] m, ``int` `n)``{``    ``int` `i, j;``    ``for``(i = 0; i < n; i++)``    ``{``        ``for``(j = 0; j < n; j++)``        ``{``            ``Console.Write(m[i, j] + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``}` `// Driver code``static` `void` `Main()``{``    ``int` `n = 4;``    ``int``[,] m = ``new` `int``[4, 4];``    ` `    ``fillmatrix(m, n);``    ``display(m, n);``}``}` `// This code is contributed by abhinavjain194`

## Javascript

 ``
Output

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

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up