Related Articles

# Print matrix in diagonal pattern

• Difficulty Level : Medium
• Last Updated : 09 Jul, 2021

Given a matrix of n*n size, the task is to print its elements in a diagonal pattern. ```Input : mat = {{1, 2, 3},
{4, 5, 6},
{7, 8, 9}}
Output : 1 2 4 7 5 3 6 8 9.
Explanation: Start from 1
Then from upward to downward diagonally i.e. 2 and 4
Then from downward to upward diagonally i.e 7, 5, 3
Then from up to down diagonally i.e  6, 8
Then down to up i.e. end at 9.

Input :  mat =  {{1,  2,  3,  10},
{4,  5,  6,  11},
{7,  8,  9,  12},
{13, 14, 15, 16}}
Output:  1 2 4 7 5 3 10 6 8 13 14 9 11 12 15 16 .
Explanation: Start from 1
Then from upward to downward diagonally i.e. 2 and 4
Then from downward to upward diagonally i.e 7, 5, 3
Then from upward to downward diagonally i.e. 10 6 8 13
Then from downward to upward diagonally i.e 14 9 11
Then from upward to downward diagonally i.e. 12 15
then end at 16```

Approach: From the diagram it can be seen that every element is either printed diagonally upward or diagonally downward. Start from the index (0,0) and print the elements diagonally upward then change the direction, change the column and print diagonally downwards. This cycle continues until the last element is reached.
Algorithm:

1. Create variables i=0, j=0 to store the current indices of row and column
2. Run a loop from 0 to n*n, where n is side of the matrix.
3. Use a flag isUp to decide whether the direction is upwards or downwards. Set isUp = true initially the direction is going upward.
4. If isUp = 1 then start printing elements by incrementing column index and decrementing the row index.
5. Similarly if isUp = 0, then decrement the column index and increment the row index.
6. Move to the next column or row (next starting row and column
7. Do this till all the elements get traversed.

Implementation:

## C++

 `// C++ program to print matrix in diagonal order``#include ``using` `namespace` `std;``const` `int` `MAX = 100;` `void` `printMatrixDiagonal(``int` `mat[MAX][MAX], ``int` `n)``{``    ``// Initialize indexes of element to be printed next``    ``int` `i = 0, j = 0;` `    ``// Direction is initially from down to up``    ``bool` `isUp = ``true``;` `    ``// Traverse the matrix till all elements get traversed``    ``for` `(``int` `k = 0; k < n * n;) {``        ``// If isUp = true then traverse from downward``        ``// to upward``        ``if` `(isUp) {``            ``for` `(; i >= 0 && j < n; j++, i--) {``                ``cout << mat[i][j] << ``" "``;``                ``k++;``            ``}` `            ``// Set i and j according to direction``            ``if` `(i < 0 && j <= n - 1)``                ``i = 0;``            ``if` `(j == n)``                ``i = i + 2, j--;``        ``}` `        ``// If isUp = 0 then traverse up to down``        ``else` `{``            ``for` `(; j >= 0 && i < n; i++, j--) {``                ``cout << mat[i][j] << ``" "``;``                ``k++;``            ``}` `            ``// Set i and j according to direction``            ``if` `(j < 0 && i <= n - 1)``                ``j = 0;``            ``if` `(i == n)``                ``j = j + 2, i--;``        ``}` `        ``// Revert the isUp to change the direction``        ``isUp = !isUp;``    ``}``}` `int` `main()``{``    ``int` `mat[MAX][MAX] = { { 1, 2, 3 },``                          ``{ 4, 5, 6 },``                          ``{ 7, 8, 9 } };` `    ``int` `n = 3;``    ``printMatrixDiagonal(mat, n);``    ``return` `0;``}`

## Java

 `// Java program to print matrix in diagonal order``class` `GFG {``    ``static` `final` `int` `MAX = ``100``;` `    ``static` `void` `printMatrixDiagonal(``int` `mat[][], ``int` `n)``    ``{``        ``// Initialize indexes of element to be printed next``        ``int` `i = ``0``, j = ``0``;` `        ``// Direction is initially from down to up``        ``boolean` `isUp = ``true``;` `        ``// Traverse the matrix till all elements get traversed``        ``for` `(``int` `k = ``0``; k < n * n;) {``            ``// If isUp = true then traverse from downward``            ``// to upward``            ``if` `(isUp) {``                ``for` `(; i >= ``0` `&& j < n; j++, i--) {``                    ``System.out.print(mat[i][j] + ``" "``);``                    ``k++;``                ``}` `                ``// Set i and j according to direction``                ``if` `(i < ``0` `&& j <= n - ``1``)``                    ``i = ``0``;``                ``if` `(j == n) {``                    ``i = i + ``2``;``                    ``j--;``                ``}``            ``}` `            ``// If isUp = 0 then traverse up to down``            ``else` `{``                ``for` `(; j >= ``0` `&& i < n; i++, j--) {``                    ``System.out.print(mat[i][j] + ``" "``);``                    ``k++;``                ``}` `                ``// Set i and j according to direction``                ``if` `(j < ``0` `&& i <= n - ``1``)``                    ``j = ``0``;``                ``if` `(i == n) {``                    ``j = j + ``2``;``                    ``i--;``                ``}``            ``}` `            ``// Revert the isUp to change the direction``            ``isUp = !isUp;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `mat[][] = { { ``1``, ``2``, ``3` `},``                        ``{ ``4``, ``5``, ``6` `},``                        ``{ ``7``, ``8``, ``9` `} };` `        ``int` `n = ``3``;``        ``printMatrixDiagonal(mat, n);``    ``}``}``// This code is contributed by Anant Agarwal.`

## Python 3

 `# Python 3 program to print matrix in diagonal order``MAX` `=` `100` `def` `printMatrixDiagonal(mat, n):``    ``# Initialize indexes of element to be printed next``    ``i ``=` `0``    ``j ``=` `0``    ``k ``=` `0``    ``# Direction is initially from down to up``    ``isUp ``=` `True` `     ``# Traverse the matrix till all elements get traversed``    ``while` `k``=` `0` `and` `j``=` `0` `and` `i

## C#

 `// C# program to print matrix in diagonal order``using` `System;``class` `GFG {``    ``static` `int` `MAX = 100;` `    ``static` `void` `printMatrixDiagonal(``int``[, ] mat, ``int` `n)``    ``{``        ``// Initialize indexes of element to be printed next``        ``int` `i = 0, j = 0;` `        ``// Direction is initially from down to up``        ``bool` `isUp = ``true``;` `        ``// Traverse the matrix till all elements get traversed``        ``for` `(``int` `k = 0; k < n * n;) {``            ``// If isUp = true then traverse from downward``            ``// to upward``            ``if` `(isUp) {``                ``for` `(; i >= 0 && j < n; j++, i--) {``                    ``Console.Write(mat[i, j] + ``" "``);``                    ``k++;``                ``}` `                ``// Set i and j according to direction``                ``if` `(i < 0 && j <= n - 1)``                    ``i = 0;``                ``if` `(j == n) {``                    ``i = i + 2;``                    ``j--;``                ``}``            ``}` `            ``// If isUp = 0 then traverse up to down``            ``else` `{``                ``for` `(; j >= 0 && i < n; i++, j--) {``                    ``Console.Write(mat[i, j] + ``" "``);``                    ``k++;``                ``}` `                ``// Set i and j according to direction``                ``if` `(j < 0 && i <= n - 1)``                    ``j = 0;``                ``if` `(i == n) {``                    ``j = j + 2;``                    ``i--;``                ``}``            ``}` `            ``// Revert the isUp to change the direction``            ``isUp = !isUp;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[, ] mat = { { 1, 2, 3 },``                        ``{ 4, 5, 6 },``                        ``{ 7, 8, 9 } };` `        ``int` `n = 3;``        ``printMatrixDiagonal(mat, n);``    ``}``}``// This code is contributed by vt_m.`

## PHP

 `= 0 && ``\$j` `< ``\$n``;``\$j``++, ``\$i``--)``            ``{``                ``echo` `\$mat``[``\$i``][``\$j``].``" "``;``                ``\$k``++;``            ``}``  ` `            ``// Set i and j according ``            ``// to direction``            ``if` `(``\$i` `< 0 && ``\$j` `<= ``\$n` `- 1)``                ``\$i` `= 0;``            ``if` `(``\$j` `== ``\$n``)``            ``{``                ``\$i` `= ``\$i` `+ 2;``                ``\$j``--;``            ``}``        ``}``  ` `        ``// If isUp = 0 then ``        ``// traverse up to down``        ``else``        ``{``            ``for` `( ; ``\$j` `>= 0 && ``                 ``\$i``<``\$n` `; ``\$i``++, ``\$j``--)``            ``{``                ``echo` `\$mat``[``\$i``][``\$j``].``" "``;``                ``\$k``++;``            ``}``  ` `            ``// Set i and j according``            ``// to direction``            ``if` `(``\$j` `< 0 && ``\$i` `<= ``\$n` `- 1)``                ``\$j` `= 0;``            ``if` `(``\$i` `== ``\$n``)``            ``{``                ``\$j` `= ``\$j` `+ 2;``                ``\$i``--;``            ``}``        ``}``  ` `        ``// Revert the isUp to``        ``// change the direction``        ``\$isUp` `= !``\$isUp``;``    ``}``}``  ` `    ``// Driver code``    ``\$mat``= ``array``(``array``(1, 2, 3),``          ``array``(4, 5, 6),``          ``array``(7, 8, 9));``  ` `    ``\$n` `= 3;``    ``printMatrixDiagonal(``\$mat``, ``\$n``);``  ` `// This code is contributed by Surbhi Tyagi ``?>`

## Javascript

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

Complexity Analysis:

• Time Complexity: O(n*n).
To traverse the matrix O(n*n) time complexity is needed.
• Space Compelxity: O(1).
As no extra space is required.

Alternate Implementation: This is another simple and compact implementation of the same approach as mentioned above.

## C++

 `// C++ program to print matrix in diagonal order``#include ``using` `namespace` `std;` `int` `main()``{``    ``// Initialize matrix``    ``int` `mat[] = { { 1, 2, 3, 4 },``                     ``{ 5, 6, 7, 8 },``                     ``{ 9, 10, 11, 12 },``                     ``{ 13, 14, 15, 16 } };``    ``// n - size``    ``// mode - switch to derive up/down traversal``    ``// it - iterator count - increases until it``    ``// reaches n and then decreases``    ``int` `n = 4, mode = 0, it = 0, lower = 0;` `    ``// 2n will be the number of iterations``    ``for` `(``int` `t = 0; t < (2 * n - 1); t++) {``        ``int` `t1 = t;``        ``if` `(t1 >= n) {``            ``mode++;``            ``t1 = n - 1;``            ``it--;``            ``lower++;``        ``}``        ``else` `{``            ``lower = 0;``            ``it++;``        ``}``        ``for` `(``int` `i = t1; i >= lower; i--) {``            ``if` `((t1 + mode) % 2 == 0) {``                ``cout << (mat[i][t1 + lower - i]) << endl;``            ``}``            ``else` `{``                ``cout << (mat[t1 + lower - i][i]) << endl;``            ``}``        ``}``    ``}``    ``return` `0;``}` `// This code is contributed by princiraj1992`

## Java

 `// Java program to print matrix in diagonal order``public` `class` `MatrixDiag {` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Initialize matrix``        ``int``[][] mat = { { ``1``, ``2``, ``3``, ``4` `},``                        ``{ ``5``, ``6``, ``7``, ``8` `},``                        ``{ ``9``, ``10``, ``11``, ``12` `},``                        ``{ ``13``, ``14``, ``15``, ``16` `} };``        ``// n - size``        ``// mode - switch to derive up/down traversal``        ``// it - iterator count - increases until it``        ``// reaches n and then decreases``        ``int` `n = ``4``, mode = ``0``, it = ``0``, lower = ``0``;` `        ``// 2n will be the number of iterations``        ``for` `(``int` `t = ``0``; t < (``2` `* n - ``1``); t++) {``            ``int` `t1 = t;``            ``if` `(t1 >= n) {``                ``mode++;``                ``t1 = n - ``1``;``                ``it--;``                ``lower++;``            ``}``            ``else` `{``                ``lower = ``0``;``                ``it++;``            ``}``            ``for` `(``int` `i = t1; i >= lower; i--) {``                ``if` `((t1 + mode) % ``2` `== ``0``) {``                    ``System.out.println(mat[i][t1 + lower - i]);``                ``}``                ``else` `{``                    ``System.out.println(mat[t1 + lower - i][i]);``                ``}``            ``}``        ``}``    ``}``}`

## Python3

 `# Python3 program to prmatrix in diagonal order` `# Driver code` `# Initialize matrix``mat ``=` `[[ ``1``, ``2``, ``3``, ``4` `],``       ``[ ``5``, ``6``, ``7``, ``8` `],``       ``[ ``9``, ``10``, ``11``, ``12` `],``       ``[ ``13``, ``14``, ``15``, ``16` `]];``       ` `# n - size``# mode - switch to derive up/down traversal``# it - iterator count - increases until it``# reaches n and then decreases``n ``=` `4``mode ``=` `0``it ``=` `0``lower ``=` `0` `# 2n will be the number of iterations``for` `t ``in` `range``(``2` `*` `n ``-` `1``):``    ``t1 ``=` `t``    ``if` `(t1 >``=` `n):``        ``mode ``+``=` `1``        ``t1 ``=` `n ``-` `1``        ``it ``-``=` `1``        ``lower ``+``=` `1``    ``else``:``        ``lower ``=` `0``        ``it ``+``=` `1` `    ``for` `i ``in` `range``(t1, lower ``-` `1``, ``-``1``):``        ``if` `((t1 ``+` `mode) ``%` `2` `=``=` `0``):``            ``print``((mat[i][t1 ``+` `lower ``-` `i]))``        ``else``:``            ``print``(mat[t1 ``+` `lower ``-` `i][i])` `# This code is contributed by princiraj1992`

## C#

 `// C# program to print matrix in diagonal order``using` `System;` `public` `class` `MatrixDiag {``    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// Initialize matrix``        ``int``[, ] mat = { { 1, 2, 3, 4 },``                        ``{ 5, 6, 7, 8 },``                        ``{ 9, 10, 11, 12 },``                        ``{ 13, 14, 15, 16 } };``        ``// n - size``        ``// mode - switch to derive up/down traversal``        ``// it - iterator count - increases until it``        ``// reaches n and then decreases``        ``int` `n = 4, mode = 0, it = 0, lower = 0;` `        ``// 2n will be the number of iterations``        ``for` `(``int` `t = 0; t < (2 * n - 1); t++) {``            ``int` `t1 = t;``            ``if` `(t1 >= n) {``                ``mode++;``                ``t1 = n - 1;``                ``it--;``                ``lower++;``            ``}``            ``else` `{``                ``lower = 0;``                ``it++;``            ``}``            ``for` `(``int` `i = t1; i >= lower; i--) {``                ``if` `((t1 + mode) % 2 == 0) {``                    ``Console.WriteLine(mat[i, t1 + lower - i]);``                ``}``                ``else` `{``                    ``Console.WriteLine(mat[t1 + lower - i, i]);``                ``}``            ``}``        ``}``    ``}``}` `// This code contributed by Rajput-Ji`

## Javascript

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

This article is contributed by Sahil Chhabra. 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.