Related Articles
Print matrix elements diagonally in spiral form
• Last Updated : 21 Dec, 2020

Given a matrix arr[][] of dimensions N * M and an integer K, the task is to print all elements of the matrix starting from the top-left element up to K diagonally in spiral form.

Examples:

Input : N=5, M=6, K=15, arr[][]={{1, 2, 3, 4, 5, 6},
{7, 8, 9, 10, 11, 12},
{13, 14, 15, 16, 17, 18},
{19, 20, 21, 22, 23, 24},
{25, 26, 27, 28, 29, 30}}
Output: 1, 2, 7, 13, 8, 3, 4, 9, 14, 19, 25, 20, 15
Explanation:

1st diagonal printed: {1}
2nd diagonal printed: {2, 7}
3rd diagonal printed: {13, 8, 3}
……
5th diagonal printed {25, 20, 15}.
Since 15 is encountered, no further matrix element is printed.

Input: N = 4, M = 3, K = 69, arr[][]={{4, 87, 24},
{17, 1, 18},
{25, 69, 97},
{19, 27, 85}}
Output: 4, 87, 17, 25, 1, 24, 18, 69

Approach: Follow the steps below to solve the problem:

1. The total number of diagonals in the matrix is N + M – 1.
2. Traverse the diagonal one by one in spiral manner.
3. For every element traversed, check if it is equal to K or not. If found to be true, print that element and terminate.
4. Otherwise, print the element and evaluate the next indices to be traversed. If i and j are the current indexes:
• While moving diagonally up i will be decremented and j will be incremented.
• While moving diagonally down i will be incremented and j will be decremented.
5. If the next index is not a valid index, then move to the next diagonal.
6. Otherwise, update the current position to the next.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; `   `// Function to check if the ` `// indices are valid or not ` `bool` `isValid(``int` `i, ``int` `j, ` `            ``int` `N, ``int` `M) ` `{ ` `    ``return` `(i >= 0 && i < N ` `            ``&& j >= 0 && j < M); ` `} `   `// Function to evaluate the next ` `// index while moving diagonally up ` `pair<``int``, ``int``> up(``int` `i, ``int` `j, ` `                ``int` `N, ``int` `M) ` `{ ` `    ``if` `(isValid(i - 1, j + 1, N, M)) ` `        ``return` `{ i - 1, j + 1 }; ` `    ``else` `        ``return` `{ -1, -1 }; ` `} `   `// Function to evaluate the next ` `// index while moving diagonally down ` `pair<``int``, ``int``> down(``int` `i, ``int` `j, ` `                    ``int` `N, ``int` `M) ` `{ ` `    ``if` `(isValid(i + 1, j - 1, N, M)) ` `        ``return` `{ i + 1, j - 1 }; ` `    ``else` `        ``return` `{ -1, -1 }; ` `} `   `// Function to print matrix elements ` `// diagonally in Spiral Form ` `void` `SpiralDiagonal(``int` `N, ``int` `M, ``int` `K, ` `                    ``vector > a) ` `{ ` `    ``int` `i = 0, j = 0; `   `    ``// Total Number of Diagonals ` `    ``// = N + M - 1 ` `    ``for` `(``int` `diagonal = 0; ` `        ``diagonal < N + M - 1; ` `        ``diagonal++) { `   `        ``while` `(1) { `   `            ``// Stop when K is ` `            ``// encountered ` `            ``if` `(a[i][j] == K) { `   `                ``cout << K; ` `                ``return``; ` `            ``} `   `            ``// Print the integer ` `            ``cout << a[i][j] << ``", "``; `   `            ``// Store the next index ` `            ``pair<``int``, ``int``> next; ` `            ``if` `(diagonal & 1) { `   `                ``next = down(i, j, N, M); ` `            ``} ` `            ``else` `{ `   `                ``next = up(i, j, N, M); ` `            ``} `   `            ``// If current index is invalid ` `            ``if` `(next.first == next.second ` `                ``&& next.first == -1) { `   `                ``// Move to the next diagonal ` `                ``if` `(diagonal & 1) { `   `                    ``(i + 1 < N) ? ++i : ++j; ` `                ``} ` `                ``else` `{ `   `                    ``(j + 1 < M) ? ++j : ++i; ` `                ``} ` `                ``break``; ` `            ``} `   `            ``// Otherwise move to the ` `            ``// next valid index ` `            ``else` `{ `   `                ``i = next.first; ` `                ``j = next.second; ` `            ``} ` `        ``} ` `    ``} ` `} `   `// Driver Code ` `int` `main() ` `{ `   `    ``int` `N = 5, M = 6, K = 15; ` `    ``vector > arr ` `        ``= { { 1, 2, 3, 4, 5, 6 }, ` `            ``{ 7, 8, 9, 10, 11, 12 }, ` `            ``{ 13, 14, 15, 16, 17, 18 }, ` `            ``{ 19, 20, 21, 22, 23, 24 }, ` `            ``{ 25, 26, 27, 28, 29, 30 } }; `   `    ``// Function Call ` `    ``SpiralDiagonal(N, M, K, arr); `   `    ``return` `0; ` `}`

## Java

 `// Java program for the ` `// above approach` `import` `java.util.*;` `import` `java.lang.*;` ` `  `class` `GFG{` `static` `class` `pair` `{` `    ``int` `first, second;` `    ``pair(``int` `f, ``int` `s)` `    ``{` `        ``this``.first = f;` `        ``this``.second = s;` `    ``}` `}`   `// Function to check if the` `// indices are valid or not` `static` `boolean` `isValid(``int` `i, ``int` `j,` `                       ``int` `N, ``int` `M)` `{` `    ``return` `(i >= ``0` `&& i < N && ` `            ``j >= ``0` `&& j < M);` `}` ` `  `// Function to evaluate the next` `// index while moving diagonally up` `static` `int``[] up(``int` `i, ``int` `j,` `                ``int` `N, ``int` `M)` `{` `    ``if` `(isValid(i - ``1``, j + ``1``, N, M))` `        ``return` `new` `int``[]{ i - ``1``, j + ``1` `};` `    ``else` `        ``return` `new` `int``[]{ -``1``, -``1` `};` `}` ` `  `// Function to evaluate the next` `// index while moving diagonally down` `static` `int``[] down(``int` `i, ``int` `j,` `                  ``int` `N, ``int` `M)` `{` `    ``if` `(isValid(i + ``1``, j - ``1``, N, M))` `        ``return` `new` `int``[]{ i + ``1``, j - ``1` `};` `    ``else` `        ``return` `new` `int``[]{ -``1``, -``1` `};` `}` ` `  `// Function to print matrix elements` `// diagonally in Spiral Form` `static` `void` `SpiralDiagonal(``int` `N, ``int` `M, ` `                           ``int` `K, ``int``[][] a)` `{` `    ``int` `i = ``0``, j = ``0``;` ` `  `    ``// Total Number of Diagonals` `    ``// = N + M - 1` `    ``for``(``int` `diagonal = ``0``;` `            ``diagonal < N + M - ``1``;` `            ``diagonal++)` `    ``{` `        ``while` `(``true``)` `        ``{` `            `  `            ``// Stop when K is` `            ``// encountered` `            ``if` `(a[i][j] == K)` `            ``{` `                ``System.out.print(K);` `                ``return``;` `            ``}` `            `  `            ``// Print the integer` `            ``System.out.print(a[i][j] + ``", "``);` `            `  `            ``// Store the next index` `            ``int``[] next;` `            `  `            ``if` `((diagonal & ``1``) == ``1``)` `            ``{` `                ``next = down(i, j, N, M);` `            ``}` `            ``else` `            ``{` `                ``next = up(i, j, N, M);` `            ``}` ` `  `            ``// If current index is invalid` `            ``if` `(next[``0``] == next[``1``] &&` `                ``next[``1``] == -``1``)` `            ``{` `                `  `                ``// Move to the next diagonal` `                ``if` `((diagonal & ``1``) == ``1``)` `                ``{` `                    ``if` `(i + ``1` `< N)` `                        ``++i;` `                    ``else` `                        ``++j;` `                ``}` `                ``else` `                ``{` `                    ``if` `(j + ``1` `< M)` `                        ``++j;` `                    ``else` `                        ``++i;` `                ``}` `                ``break``;` `            ``}` `            `  `            ``// Otherwise move to the` `            ``// next valid index` `            ``else` `            ``{` `                ``i = next[``0``];` `                ``j = next[``1``];` `            ``}` `        ``}` `    ``}` `}` ` `  `// Driver code` `public` `static` `void` `main (String[] args)` `{` `    ``int` `N = ``5``, M = ``6``, K = ``15``;` `    ``int``[][] arr = { { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `},` `                    ``{ ``7``, ``8``, ``9``, ``10``, ``11``, ``12` `},` `                    ``{ ``13``, ``14``, ``15``, ``16``, ``17``, ``18` `},` `                    ``{ ``19``, ``20``, ``21``, ``22``, ``23``, ``24` `},` `                    ``{ ``25``, ``26``, ``27``, ``28``, ``29``, ``30` `} };` `                    `  `    ``// Function Call` `    ``SpiralDiagonal(N, M, K, arr);` `}` `}`   `// This code is contributed by offbeat`

## Python3

 `# Python3 program for the ` `# above approach`   `# Function to check if the` `# indices are valid or not` `def` `isValid(i, j, N, M):` `    ``return` `(i >``=` `0` `and` `i < N ``and` `j >``=` `0` `and` `j < M)`   `# Function to evaluate the next` `# index while moving diagonally up` `def` `up(i, j, N, M):` `    ``if``(isValid(i ``-` `1``, j ``+` `1``, N, M)):` `        ``return` `[i ``-` `1``, j ``+` `1` `]` `    ``else``:` `        ``return` `[``-``1``, ``-``1``]`   `# Function to evaluate the next` `# index while moving diagonally down` `def` `down(i, j, N, M):` `    ``if``(isValid(i ``+` `1``, j ``-` `1``, N, M)):` `        ``return` `[i ``+` `1``, j ``-` `1` `]` `    ``else``:` `        ``return` `[``-``1``, ``-``1``]`   `# Function to print matrix elements` `# diagonally in Spiral Form` `def` `SpiralDiagonal(N, M, K, a):` `    ``i ``=` `0` `    ``j ``=` `0`   `    ``# Total Number of Diagonals` `    ``# = N + M - 1` `    ``for` `diagonal ``in` `range``(N ``+` `M ``-` `1``):`   `        ``while``(``True``):` `          `  `            ``# Stop when K is` `            ``# encountered` `            ``if``(a[i][j] ``=``=` `K):` `                ``print``(K, end ``=` `"")` `                ``return` `              `  `            ``# Print the integer` `            ``print``(a[i][j], ``", "``, end``=``"``", sep="``")`   `            ``# Store the next index` `            ``next` `=` `[]` `            ``if``((diagonal & ``1``) ``=``=` `1``):` `                ``next` `=` `down(i, j, N, M)` `            ``else``:` `                ``next` `=` `up(i, j, N, M)`   `            ``# If current index is invalid` `            ``if``(``next``[``0``] ``=``=` `next``[``1``] ``and` `next``[``1``] ``=``=` `-``1``):` `                `  `                ``# Move to the next diagonal` `                ``if``((diagonal & ``1``) ``=``=` `1``):` `                    ``if``(i ``+` `1` `< N):` `                        ``i ``+``=` `1` `                    ``else``:` `                        ``j ``+``=` `1` `                ``else``:` `                    ``if``(j ``+` `1` `< M):` `                        ``j ``+``=` `1` `                    ``else``:` `                        ``i ``+``=` `1` `                ``break` `                `  `            ``# Otherwise move to the` `            ``# next valid index` `            ``else``:` `                ``i ``=` `next``[``0``]` `                ``j ``=` `next``[``1``]`   `# Driver code` `N ``=` `5` `M ``=` `6` `K ``=` `15` `arr ``=` `[[``1``, ``2``, ``3``, ``4``, ``5``, ``6` `],` `       ``[ ``7``, ``8``, ``9``, ``10``, ``11``, ``12``],` `       ``[``13``, ``14``, ``15``, ``16``, ``17``, ``18` `],` `       ``[``19``, ``20``, ``21``, ``22``, ``23``, ``24``],` `       ``[``25``, ``26``, ``27``, ``28``, ``29``, ``30``]]`   `# Function Call` `SpiralDiagonal(N, M, K, arr);`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program for the` `// above approach` `using` `System;`   `class` `GFG{`   `// Function to check if the` `// indices are valid or not` `static` `bool` `isValid(``int` `i, ``int` `j, ` `                    ``int` `N, ``int` `M)` `{` `    ``return` `(i >= 0 && i < N && ` `            ``j >= 0 && j < M);` `}`   `// Function to evaluate the next` `// index while moving diagonally up` `static` `int``[] up(``int` `i, ``int` `j, ``int` `N, ``int` `M)` `{` `    ``if` `(isValid(i - 1, j + 1, N, M))` `        ``return` `new` `int``[]{ i - 1, j + 1 };` `    ``else` `        ``return` `new` `int``[]{ -1, -1 };` `}`   `// Function to evaluate the next` `// index while moving diagonally down` `static` `int``[] down(``int` `i, ``int` `j, ``int` `N, ``int` `M)` `{` `    ``if` `(isValid(i + 1, j - 1, N, M))` `        ``return` `new` `int``[]{ i + 1, j - 1 };` `    ``else` `        ``return` `new` `int``[]{ -1, -1 };` `}`   `// Function to print matrix elements` `// diagonally in Spiral Form` `static` `void` `SpiralDiagonal(``int` `N, ``int` `M, ``int` `K,` `                           ``int``[, ] a)` `{` `    ``int` `i = 0, j = 0;`   `    ``// Total Number of Diagonals` `    ``// = N + M - 1` `    ``for``(``int` `diagonal = 0;` `            ``diagonal < N + M - 1;` `            ``diagonal++) ` `    ``{` `        ``while` `(``true``) ` `        ``{` `            `  `            ``// Stop when K is` `            ``// encountered` `            ``if` `(a[i, j] == K)` `            ``{` `                ``Console.Write(K);` `                ``return``;` `            ``}`   `            ``// Print the integer` `            ``Console.Write(a[i, j] + ``", "``);`   `            ``// Store the next index` `            ``int``[] next;`   `            ``if` `((diagonal & 1) == 1) ` `            ``{` `                ``next = down(i, j, N, M);` `            ``}` `            ``else` `            ``{` `                ``next = up(i, j, N, M);` `            ``}`   `            ``// If current index is invalid` `            ``if` `(next == next &&` `                ``next == -1)` `            ``{` `                `  `                ``// Move to the next diagonal` `                ``if` `((diagonal & 1) == 1) ` `                ``{` `                    ``if` `(i + 1 < N)` `                        ``++i;` `                    ``else` `                        ``++j;` `                ``}` `                ``else` `                ``{` `                    ``if` `(j + 1 < M)` `                        ``++j;` `                    ``else` `                        ``++i;` `                ``}` `                ``break``;` `            ``}`   `            ``// Otherwise move to the` `            ``// next valid index` `            ``else` `            ``{` `                ``i = next;` `                ``j = next;` `            ``}` `        ``}` `    ``}` `}`   `// Driver code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``int` `N = 5, M = 6, K = 15;` `    ``int``[, ] arr = { { 1, 2, 3, 4, 5, 6 },` `                    ``{ 7, 8, 9, 10, 11, 12 },` `                    ``{ 13, 14, 15, 16, 17, 18 },` `                    ``{ 19, 20, 21, 22, 23, 24 },` `                    ``{ 25, 26, 27, 28, 29, 30 } };`   `    ``// Function Call` `    ``SpiralDiagonal(N, M, K, arr);` `}` `}`   `// This code is contributed by grand_master`

Output:

`1, 2, 7, 13, 8, 3, 4, 9, 14, 19, 25, 20, 15`

Time Complexity: O(N*M)
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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :