# Zigzag (or diagonal) traversal of Matrix

Given a 2D matrix, print all elements of the given matrix in diagonal order. For example, consider the following 5 X 4 input matrix.

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

Diagonal printing of the above matrix is

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

Another example: ## We strongly recommend that you click here and practice it, before moving on to the solution.

Following is the code for diagonal printing.

The diagonal printing of a given matrix “matrix[ROW][COL]” always has “ROW + COL – 1” lines in output.

## C++

 `#include ` `#include ` ` `  `#define ROW 5 ` `#define COL 4 ` ` `  `// A utility function to find min of two integers ` `int` `minu(``int` `a, ``int` `b) ` `{ ``return` `(a < b)? a: b; } ` ` `  `// A utility function to find min of three integers ` `int` `min(``int` `a, ``int` `b, ``int` `c) ` `{ ``return` `minu(minu(a, b), c);} ` ` `  `// A utility function to find max of two integers ` `int` `max(``int` `a, ``int` `b) ` `{ ``return` `(a > b)? a: b; } ` ` `  `// The main function that prints given matrix in diagonal order ` `void` `diagonalOrder(``int` `matrix[][COL]) ` `{ ` `    ``// There will be ROW+COL-1 lines in the output ` `    ``for` `(``int` `line=1; line<=(ROW + COL -1); line++) ` `    ``{ ` `        ``/* Get column index of the first element in this line of output. ` `           ``The index is 0 for first ROW lines and line - ROW for remaining ` `           ``lines  */` `        ``int` `start_col =  max(0, line-ROW); ` ` `  `        ``/* Get count of elements in this line. The count of elements is ` `           ``equal to minimum of line number, COL-start_col and ROW */` `         ``int` `count = min(line, (COL-start_col), ROW); ` ` `  `        ``/* Print elements of this line */` `        ``for` `(``int` `j=0; j

## Java

 `class` `GFG { ` `static` `final` `int` `ROW = ``5``; ` `static` `final` `int` `COL = ``4``; ` ` `  `// A utility function to find min  ` `// of two integers ` `static` `int` `min(``int` `a, ``int` `b) { ` `    ``return` `(a < b) ? a : b; ` `    ``} ` ` `  `// A utility function to find min ` `// of three integers ` `static` `int` `min(``int` `a, ``int` `b, ``int` `c) { ` `    ``return` `min(min(a, b), c); ` `    ``} ` ` `  `// A utility function to find max  ` `// of two integers ` `static` `int` `max(``int` `a, ``int` `b) {  ` `    ``return` `(a > b) ? a : b; ` `    ``} ` ` `  `// The main function that prints given ` `// matrix in diagonal order ` `static` `void` `diagonalOrder(``int` `matrix[][]) { ` ` `  `    ``// There will be ROW+COL-1 lines in the output ` `    ``for` `(``int` `line = ``1``; line <= (ROW + COL - ``1``); line++) { ` ` `  `    ``// Get column index of the first element in this ` `    ``// line of output.The index is 0 for first ROW ` `    ``// lines and line - ROW for remaining lines ` `    ``int` `start_col = max(``0``, line - ROW); ` ` `  `    ``// Get count of elements in this line. The count ` `    ``// of elements is equal to minimum of line number, ` `    ``// COL-start_col and ROW  ` `    ``int` `count = min(line, (COL - start_col), ROW); ` ` `  `    ``// Print elements of this line  ` `    ``for` `(``int` `j = ``0``; j < count; j++) ` `        ``System.out.print(matrix[min(ROW, line) - j - ``1``] ` `                            ``[start_col + j] + ``" "``); ` ` `  `    ``// Print elements of next diagonal on next line ` `    ``System.out.println(); ` `    ``} ` `} ` ` `  `// Utility function to print a matrix ` `static` `void` `printMatrix(``int` `matrix[][]) { ` `    ``for` `(``int` `i = ``0``; i < ROW; i++) { ` `    ``for` `(``int` `j = ``0``; j < COL; j++) ` `        ``System.out.print(matrix[i][j] + ``" "``); ` `    ``System.out.print(``"\n"``); ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) { ` `    ``int` `M[][] = { ` `        ``{``1``, ``2``, ``3``, ``4``},     {``5``, ``6``, ``7``, ``8``},     {``9``, ``10``, ``11``, ``12``}, ` `        ``{``13``, ``14``, ``15``, ``16``}, {``17``, ``18``, ``19``, ``20``}, ` `    ``}; ` `    ``System.out.print(``"Given matrix is \n"``); ` `    ``printMatrix(M); ` ` `  `    ``System.out.print(``"\nDiagonal printing of matrix is \n"``); ` `    ``diagonalOrder(M); ` `} ` `} ` `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python3 program to print all elements ` `# of given matrix in diagonal order ` `ROW ``=` `5` `COL ``=` `4` ` `  `# Main function that prints given ` `# matrix in diagonal order ` `def` `diagonalOrder(matrix) : ` `     `  `    ``# There will be ROW+COL-1 lines in the output ` `    ``for` `line ``in` `range``(``1``, (ROW ``+` `COL)) : ` `        ``# Get column index of the first element ` `        ``# in this line of output. The index is 0 ` `        ``# for first ROW lines and line - ROW for ` `        ``# remaining lines  ` `        ``start_col ``=` `max``(``0``, line ``-` `ROW) ` ` `  `        ``# Get count of elements in this line. ` `        ``# The count of elements is equal to ` `        ``# minimum of line number, COL-start_col and ROW  ` `        ``count ``=` `min``(line, (COL ``-` `start_col), ROW) ` ` `  `        ``# Print elements of this line  ` `        ``for` `j ``in` `range``(``0``, count) : ` `            ``print``(matrix[``min``(ROW, line) ``-` `j ``-` `1``] ` `                        ``[start_col ``+` `j], end ``=` `"\t"``) ` ` `  `        ``print``() ` `     `  `     `  `# Utility function to print a matrix ` `def` `printMatrix(matrix) : ` `    ``for` `i ``in` `range``(``0``, ROW) : ` `        ``for` `j ``in` `range``(``0``, COL) : ` `            ``print``(matrix[i][j], end ``=` `"\t"``) ` `             `  `        ``print``() ` `         `  ` `  `# Driver COde ` `M ``=` `[ [``1``, ``2``, ``3``, ``4``], ` `    ``[``5``, ``6``, ``7``, ``8``], ` `    ``[``9``, ``10``, ``11``, ``12``], ` `    ``[``13``, ``14``, ``15``, ``16``], ` `    ``[``17``, ``18``, ``19``, ``20``] ] ` `print``(``"Given matrix is "``) ` `printMatrix(M) ` ` `  `print` `(``"\nDiagonal printing of matrix is "``) ` `diagonalOrder(M) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// C# program to print all elements ` `// of given matrix in diagonal order ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``static` `int` `ROW = 5; ` `    ``static` `int` `COL = 4; ` ` `  `     `  `    ``// The main function that prints given ` `    ``// matrix in diagonal order ` `    ``static` `void` `diagonalOrder(``int` `[,]matrix) { ` `     `  `        ``// There will be ROW+COL-1 lines in the output ` `        ``for` `(``int` `line = 1; line <= (ROW + COL - 1); line++) ` `        ``{ ` `     `  `            ``// Get column index of the first element ` `            ``// in this line of output.The index is 0  ` `            ``// for first ROW lines and line - ROW for  ` `            ``// remaining lines ` `            ``int` `start_col = Math.Max(0, line - ROW); ` `         `  `            ``// Get count of elements in this line. The ` `            ``// count of elements is equal to minimum of  ` `            ``// line number, COL-start_col and ROW  ` `            ``int` `count = Math.Min(line, Math.Min( ` `                                  ``(COL - start_col), ROW)); ` `     `  `            ``// Print elements of this line  ` `            ``for` `(``int` `j = 0; j < count; j++) ` `                ``Console.Write(matrix[ Math.Min(ROW, line)  ` `                            ``- j - 1, start_col + j] + ``" "``); ` `         `  `            ``// Print elements of next diagonal on next line ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` `     `  `    ``// Utility function to print a matrix ` `    ``static` `void` `printMatrix(``int` `[,]matrix) { ` `        ``for` `(``int` `i = 0; i < ROW; i++) { ` `            ``for` `(``int` `j = 0; j < COL; j++) ` `                ``Console.Write(matrix[i,j] + ``" "``); ` `                 `  `            ``Console.WriteLine(``"\n"``); ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() { ` `        ``int` `[,]M = {{1, 2, 3, 4}, ` `                    ``{5, 6, 7, 8}, ` `                    ``{9, 10, 11, 12}, ` `                    ``{13, 14, 15, 16},  ` `                    ``{17, 18, 19, 20}}; ` `                     `  `        ``Console.Write(``"Given matrix is \n"``); ` `        ``printMatrix(M); ` `     `  `        ``Console.Write(``"\nDiagonal printing"`  `                     ``+ ``" of matrix is \n"``); ` `                      `  `        ``diagonalOrder(M); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

## PHP

 ` `

Output:

```Given matrix is
1     2     3     4
5     6     7     8
9    10    11    12
13    14    15    16
17    18    19    20

Diagonal printing of matrix is
1
5     2
9     6     3
13    10     7     4
17    14    11     8
18    15    12
19    16
20```

Below is an Alternate Method to solve the above problem.

```Matrix =>       1     2     3     4
5     6     7     8
9     10    11   12
13    14    15   16
17    18    19   20

Observe the sequence
1 /  2 /  3 /  4
/ 5  /  6 /  7 /  8
/  9 / 10 / 11 / 12
/ 13 / 14 / 15 / 16
/ 17 / 18 / 19 / 20
```

## C++

 `#include ` `#define R 5 ` `#define C 4 ` `using` `namespace` `std; ` ` `  `bool` `isValid(``int` `i, ``int` `j) ` `{ ` `    ``if` `(i < 0 || i >= R || j >= C || j < 0) ``return` `false``; ` `    ``return` `true``; ` `} ` ` `  `void` `diagonalOrder(``int` `arr[][C]) ` `{ ` `    ``/* through this for loop we choose each element of first column ` `    ``as starting point and print diagonal starting at it. ` `    ``arr, arr....arr[R-1] are all starting points */` `    ``for` `(``int` `k = 0; k < R; k++) ` `    ``{ ` `        ``cout << arr[k] << ``" "``; ` `        ``int` `i = k-1;    ``// set row index for next point in diagonal ` `        ``int` `j = 1;        ``//    set column index for next point in diagonal ` ` `  `        ``/* Print Diagonally upward */` `        ``while` `(isValid(i,j)) ` `        ``{ ` `            ``cout << arr[i][j] << ``" "``; ` `            ``i--; ` `            ``j++;    ``// move in upright direction ` `        ``} ` `        ``cout << endl; ` `    ``} ` ` `  `    ``/* through this for loop we choose each element of last row ` `       ``as starting point (except the [c-1] it has already been ` `       ``processed in previous for loop) and print diagonal starting at it. ` `       ``arr[R-1], arr[R-1]....arr[R-1][c-1] are all starting points */` ` `  `    ``//Note : we start from k = 1 to C-1; ` `    ``for` `(``int` `k = 1; k < C; k++) ` `    ``{ ` `        ``cout << arr[R-1][k] << ``" "``; ` `        ``int` `i = R-2; ``// set row index for next point in diagonal ` `        ``int` `j = k+1; ``// set column index for next point in diagonal ` ` `  `        ``/* Print Diagonally upward */` `        ``while` `(isValid(i,j)) ` `        ``{ ` `            ``cout << arr[i][j] << ``" "``; ` `            ``i--; ` `            ``j++; ``// move in upright direction ` `        ``} ` `        ``cout << endl; ` `    ``} ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` ` `  `    ``int` `arr[][C] = {{1, 2, 3, 4}, ` `        ``{5, 6, 7, 8}, ` `        ``{9, 10, 11, 12}, ` `        ``{13, 14, 15, 16}, ` `        ``{17, 18, 19, 20}, ` `    ``}; ` `    ``diagonalOrder(arr); ` `    ``return` `0; ` `} `

## Java

 `// JAVA Code for Zigzag (or diagonal)  ` `// traversal of Matrix ` `   `  `   ``class` `GFG{ ` `    `  `     ``public` `static` `int` `R,C; ` `      `  `     ``private` `static` `void` `diagonalOrder(``int``[][] arr) { ` `          `  `             ``/* through this for loop we choose each element ` `             ``of first column as starting point and print  ` `             ``diagonal starting at it. arr, arr ` `             ``....arr[R-1] are all starting points */` `             ``for` `(``int` `k = ``0``; k < R; k++) ` `             ``{ ` `                 ``System.out.print(arr[k][``0``] + ``" "``); ` `                  `  `                 ``int` `i = k - ``1``;    ``// set row index for next ` `                                   ``// point in diagonal ` `                 ``int` `j = ``1``;       ``//  set column index for  ` `                                  ``// next point in diagonal ` `           `  `                 ``/* Print Diagonally upward */` `                 ``while` `(isValid(i, j)) ` `                 ``{ ` `                     ``System.out.print(arr[i][j] + ``" "``); ` `                      `  `                     ``i--; ` `                     ``j++;    ``// move in upright direction ` `                 ``} ` `                  `  `                 ``System.out.println(``""``); ` `             ``} ` `           `  `             ``/* through this for loop we choose each element ` `                ``of last row as starting point (except the  ` `                ``[c-1] it has already been processed in  ` `                ``previous for loop) and print diagonal  ` `                ``starting at it. arr[R-1], arr[R-1].... ` `                ``arr[R-1][c-1] are all starting points */` `           `  `             ``// Note : we start from k = 1 to C-1; ` `             ``for` `(``int` `k = ``1``; k < C; k++) ` `             ``{ ` `                 ``System.out.print(arr[R-``1``][k] + ``" "``); ` `                  `  `                 ``int` `i = R - ``2``; ``// set row index for next  ` `                                ``// point in diagonal ` `                 ``int` `j = k + ``1``; ``// set column index for   ` `                                ``// next point in diagonal ` `           `  `                 ``/* Print Diagonally upward */` `                 ``while` `(isValid(i, j)) ` `                 ``{ ` `                     ``System.out.print(arr[i][j] + ``" "``); ` `                      `  `                     ``i--; ` `                     ``j++; ``// move in upright direction ` `                 ``} ` `                  `  `                 ``System.out.println(``""``); ` `             ``} ` `         ``} ` `             `  `    ``public` `static`  `boolean` `isValid(``int` `i, ``int` `j) ` `     ``{ ` `         ``if` `(i < ``0` `|| i >= R || j >= C || j < ``0``) ``return` `false``; ` `         ``return` `true``; ` `     ``} ` `      `  `          ``// driver program to test above function ` `          ``public` `static` `void` `main(String[] args) { ` `              ``int` `arr[][] = { {``1``, ``2``, ``3``, ``4``}, ` `                              ``{``5``, ``6``, ``7``, ``8``}, ` `                              ``{``9``, ``10``, ``11``, ``12``}, ` `                              ``{``13``, ``14``, ``15``, ``16``}, ` `                              ``{``17``, ``18``, ``19``, ``20``}, }; ` `               `  `              ``R=arr.length; ` `              ``C=arr[``0``].length; ` `               `  `              ``diagonalOrder(arr); ` `        ``} ` ` ``} ` `         `  `    ``// This code is contributed by Arnav Kr. Mandal. `

## Python3

 `# Python3 program to print all elements ` `# of given matrix in diagonal order ` `R ``=` `5` `C ``=` `4` ` `  `def` `isValid( i, j) : ` `    ``if` `(i < ``0` `or` `i >``=` `R ``or` `j >``=` `C ``or` `j < ``0``) : ` `        ``return` `False` `    ``return` `True` `     `  ` `  `def` `diagonalOrder(arr) : ` `     `  `    ``# through this for loop we choose each element ` `    ``# of first column as starting point and print ` `    ``# diagonal starting at it.  ` `    ``# arr, arr....arr[R-1] ` `    ``# are all starting points  ` `    ``for` `k ``in` `range``(``0``, R) : ` `        ``print``(arr[k][``0``], end ``=` `"  "``) ` `         `  `        ``# set row index for next point in diagonal ` `        ``i ``=` `k ``-` `1`  `         `  `        ``# set column index for next point in diagonal ` `        ``j ``=` `1`     ` `  `        ``# Print Diagonally upward  ` `        ``while` `(isValid(i, j)) : ` `            ``print``(arr[i][j], end ``=` `"  "``) ` `            ``i ``-``=` `1` `            ``j ``+``=` `1` `# move in upright direction ` `         `  `        ``print``() ` ` `  `    ``# Through this for loop we choose each  ` `    ``# element of last row as starting point ` `    ``# (except the [c-1] it has already been ` `    ``# processed in previous for loop) and print ` `    ``# diagonal starting at it. ` `    ``# arr[R-1], arr[R-1]....arr[R-1][c-1] ` `    ``# are all starting points ` ` `  `    ``# Note : we start from k = 1 to C-1; ` `    ``for` `k ``in` `range``(``1``, C) : ` `        ``print``(arr[R``-``1``][k], end ``=` `"  "``) ` `         `  `        ``# set row index for next point in diagonal ` `        ``i ``=` `R ``-` `2` `         `  `        ``# set column index for next point in diagonal ` `        ``j ``=` `k ``+` `1`      ` `  `        ``# Print Diagonally upward  ` `        ``while` `(isValid(i, j)) : ` `            ``print``( arr[i][j], end ``=` `"  "``) ` `            ``i ``-``=` `1` `            ``j ``+``=` `1` `# move in upright direction ` `         `  `        ``print``() ` `         `  `# Driver Code ` `arr ``=` `[ [``1``, ``2``, ``3``, ``4``], ` `        ``[``5``, ``6``, ``7``, ``8``], ` `        ``[``9``, ``10``, ``11``, ``12``], ` `        ``[``13``, ``14``, ``15``, ``16``], ` `        ``[``17``, ``18``, ``19``, ``20``] ] ` `diagonalOrder(arr) ` ` `  `# This code is contributed by Nikita Tiwari. `

## C#

 `// C# Code for Zigzag (or diagonal)  ` `// traversal of Matrix ` `using` `System; ` ` `  `class` `GFG ` `{ ` `public` `static` `int` `R, C; ` ` `  `private` `static` `void` `diagonalOrder(``int``[,] arr)  ` `{ ` `     `  `    ``/* through this for loop we  ` `    ``choose each element of first ` `    ``column as starting point and  ` `    ``print diagonal starting at it.  ` `    ``arr[0,0], arr[1,0]....arr[R-1,0]  ` `    ``are all starting points */` `    ``for` `(``int` `k = 0; k < R; k++) ` `    ``{ ` `        ``Console.Write(arr[k, 0] + ``" "``); ` `         `  `        ``int` `i = k - 1;  ``// set row index for next ` `                        ``// point in diagonal ` `        ``int` `j = 1;    ``// set column index for  ` `                    ``// next point in diagonal ` `     `  `        ``/* Print Diagonally upward */` `        ``while` `(isValid(i, j)) ` `        ``{ ` `            ``Console.Write(arr[i, j] + ``" "``); ` `             `  `            ``i--; ` `            ``j++; ``// move in upright direction ` `        ``} ` `         `  `        ``Console.Write(``"\n"``); ` `    ``} ` `     `  `    ``/*  through this for loop we  ` `        ``choose each element of last  ` `        ``row as starting point (except  ` `        ``the [c-1] it has already  ` `        ``been processed in previous for  ` `        ``loop) and print diagonal starting ` `        ``at it. arr[R-1,0], arr[R-1,1].... ` `        ``arr[R-1,c-1] are all starting points */` `     `  `    ``// Note : we start from k = 1 to C-1; ` `    ``for` `(``int` `k = 1; k < C; k++) ` `    ``{ ` `        ``Console.Write(arr[R - 1, k] + ``" "``); ` `         `  `        ``int` `i = R - 2;  ``// set row index for next  ` `                        ``// point in diagonal ` `        ``int` `j = k + 1;  ``// set column index for  ` `                        ``// next point in diagonal ` `     `  `        ``/* Print Diagonally upward */` `        ``while` `(isValid(i, j)) ` `        ``{ ` `            ``Console.Write(arr[i, j] + ``" "``); ` `             `  `            ``i--; ` `            ``j++; ``// move in upright direction ` `        ``} ` `         `  `        ``Console.Write(``"\n"``); ` `    ``} ` `} ` `     `  `public` `static` `bool` `isValid(``int` `i, ``int` `j) ` `{ ` `    ``if` `(i < 0 || i >= R ||  ` `        ``j >= C || j < 0) ``return` `false``; ` `    ``return` `true``; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main()  ` `{ ` `    ``int` `[,]arr = {{1, 2, 3, 4}, ` `                  ``{5, 6, 7, 8}, ` `                  ``{9, 10, 11, 12}, ` `                  ``{13, 14, 15, 16}, ` `                  ``{17, 18, 19, 20}}; ` `         `  `    ``R = arr.GetLength(0); ` `    ``C = arr.GetLength(1); ` `         `  `    ``diagonalOrder(arr); ` `} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

## PHP

 `= R ||  ` `        ``\$j` `>= C || ``\$j` `< 0) ``return` `false;  ` `    ``return` `true;  ` `}  ` ` `  `function` `diagonalOrder(&``\$arr``)  ` `{  ` `    ``/* through this for loop we choose  ` `    ``each element of first column as  ` `    ``starting point and print diagonal   ` `    ``starting at it.  ` `    ``arr, arr....arr[R-1] ` `    ``are all starting points */` `    ``for` `(``\$k` `= 0; ``\$k` `< R; ``\$k``++)  ` `    ``{  ` `        ``echo` `\$arr``[``\$k``] . ``" "``;  ` `        ``\$i` `= ``\$k` `- 1; ``// set row index for next ` `                     ``// point in diagonal  ` `        ``\$j` `= 1; ``// set column index for next  ` `                ``// point in diagonal  ` ` `  `        ``/* Print Diagonally upward */` `        ``while` `(isValid(``\$i``,``\$j``))  ` `        ``{  ` `            ``echo` `\$arr``[``\$i``][``\$j``] . ``" "``;  ` `            ``\$i``--;  ` `            ``\$j``++; ``// move in upright direction  ` `        ``}  ` `        ``echo` `"\n"``;  ` `    ``}  ` ` `  `    ``/* through this for loop we choose each  ` `    ``element of last row as starting point  ` `    ``(except the [c-1] it has already been  ` `    ``processed in previous for loop) and print ` `    ``diagonal starting at it. arr[R-1], ` `    ``arr[R-1]....arr[R-1][c-1] are all  ` `    ``starting points */` ` `  `    ``//Note : we start from k = 1 to C-1;  ` `    ``for` `(``\$k` `= 1; ``\$k` `< C; ``\$k``++)  ` `    ``{  ` `        ``echo` `\$arr``[R - 1][``\$k``] . ``" "``;  ` `        ``\$i` `= R - 2; ``// set row index for next  ` `                    ``// point in diagonal  ` `        ``\$j` `= ``\$k` `+ 1; ``// set column index for next ` `                     ``// point in diagonal  ` ` `  `        ``/* Print Diagonally upward */` `        ``while` `(isValid(``\$i``, ``\$j``))  ` `        ``{  ` `            ``echo` `\$arr``[``\$i``][``\$j``] . ``" "``;  ` `            ``\$i``--;  ` `            ``\$j``++; ``// move in upright direction  ` `        ``}  ` `        ``echo` `"\n"``; ` `    ``}  ` `}  ` ` `  `// Driver Code ` `\$arr` `= ``array``(``array``(1, 2, 3, 4),  ` `             ``array``(5, 6, 7, 8),  ` `             ``array``(9, 10, 11, 12),  ` `             ``array``(13, 14, 15, 16),  ` `             ``array``(17, 18, 19, 20));  ` `diagonalOrder(``\$arr``);  ` ` `  `// This code is contributed  ` `// by rathbhupendra ` `?> `

Output:

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

Thanks to Gaurav Ahirwar for suggesting this method.