# Print matrix in diagonal pattern

Given a matrix of n*n size, the task is to print its elements in diagonal pattern. ```Input : mat = {{1, 2, 3},
{4, 5, 6},
{7, 8, 9}}
Output : 1 2 4 7 5 3 6 8 9.
Explanation: We 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 .
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

1. We use a flag isUp to decide whether we need to go upward direction or downward direction. We set isUp = true initially that first we are going upward.
2. If isUp = 1 then start printing elements by incrementing column index and decrementing the row index.
3. Similarly if isUp = 0, then decrement the column index and increment the row index.
4. Do this till all the elements get traversed.

Below is the implementation of above steps.

## 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 mits  ` `?> `

Output:

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

Another approach to print the elements of a given matrix of n*n size in diagonal pattern is given below.

## 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 `

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 contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.