# Print matrix in zig-zag fashion from the last column

• Last Updated : 12 Sep, 2022

Given a matrix of 2-Dimensional array of n rows and n columns. Print this matrix in ZIG-ZAG fashion starting from column n-1 as shown in the figure below. Examples:

```Input: mat[][] =
1 2 3
4 5 6
7 8 9
Output: 3 2 6 9 5 1 4 8 7

Input: mat[][] =
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Output: 4 3 8 12 7 2 1 6 11 16 15 10 5 9 14 13```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Algorithm:

1. Start traversing from top right cell belonging to row 0 and column n-1.
2. First move will always be towards LEFT(WEST) direction.
3. We make a horizontal/vertical move in case the move is odd numbered.
4. If the last move was in NORTH-WEST direction, move LEFT if there is no wall move towards LEFT, move DOWN in case there is a wall on the LEFT.
5. If the last move was in SOUTH-EAST direction, move DOWN if there is no wall DOWNWARDS, move LEFT in case there is a wall DOWNWARDS.
6. We make a diagonal move in case the move is even numbered.
7. We choose to move towards SOUTH-EAST and NORTH-WEST directions alternatively starting with SOUTH-EAST move.
8. In a single diagonal move we keep traversing multiple cells in the same direction until we reach any of the walls of the matrix. Pseudocode:
```if ((move_cnt >> 1) & 1) {
// move south east
}
else {
// move north west
}```

Variables Used

• mat: Given NxN matrix
• cur_x: Current row number
• cur_y: Current column number
• prev_move: Used to keep track of previous move
• move_cnt: Used to keep track of number of moves made
• cell_cnt: Used to keep track of number of cells traversed

Implementation:

## C++

 `// C++ program for traversing a matrix from column n-1``#include ``using` `namespace` `std;` `// Function used for traversing over the given matrix``void` `traverseMatrix(vector > mat, ``int` `n)``{` `    ``// Initial cell coordinates``    ``int` `cur_x = 0, cur_y = n - 1;` `    ``// Variable used for keeping track of last move``    ``string prev_move = ``""``;` `    ``// Variable used for keeping count``    ``// of cells traversed till next move``    ``int` `move_cnt = 1;``    ``int` `cell_cnt = 1;``    ``printf``(``"%d "``, mat[cur_x][cur_y]);` `    ``while` `(cell_cnt < n * n) {` `        ``// odd numbered move [SINGLE VERTICAL/HORIZONTAL]``        ``if` `(move_cnt & 1) {` `            ``// last move was made in north east direction``            ``if` `(prev_move == ``"NORTH_WEST"` `or prev_move == ``""``) {``                ``// move left``                ``if` `(cur_y != 0) {``                    ``--cur_y;``                    ``prev_move = ``"LEFT"``;``                ``}``                ``// move down``                ``else` `{``                    ``++cur_x;``                    ``prev_move = ``"DOWN"``;``                ``}``            ``}` `            ``// last move was made in south east direction``            ``else` `{``                ``// move down``                ``if` `(cur_x != n - 1) {``                    ``++cur_x;``                    ``prev_move = ``"DOWN"``;``                ``}``                ``// move left``                ``else` `{``                    ``--cur_y;``                    ``prev_move = ``"LEFT"``;``                ``}``            ``}``            ``printf``(``"%d "``, mat[cur_x][cur_y]);``            ``++cell_cnt;``        ``}` `        ``// even numbered move/s [DIAGONAL/S]``        ``else` `{``            ``if` `((move_cnt >> 1) & 1) {` `                ``// move south east``                ``while` `(cur_x < n - 1 and cur_y < n - 1) {``                    ``++cur_x;``                    ``++cur_y;``                    ``prev_move = ``"SOUTH_EAST"``;``                    ``printf``(``"%d "``, mat[cur_x][cur_y]);``                    ``++cell_cnt;``                ``}``            ``}``            ``else` `{``                ``// move north west``                ``while` `(cur_x > 0 and cur_y > 0) {``                    ``--cur_x;``                    ``--cur_y;``                    ``prev_move = ``"NORTH_WEST"``;``                    ``printf``(``"%d "``, mat[cur_x][cur_y]);``                    ``++cell_cnt;``                ``}``            ``}``        ``}``        ``++move_cnt;``    ``}``}` `// Driver function``int` `main()``{` `    ``// number of rows and columns``    ``int` `n = 5;` `    ``// 5x5 matrix``    ``vector > mat{``        ``{ 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 }``    ``};` `    ``traverseMatrix(mat, n);` `    ``return` `0;``}`

## Java

 `// Java program for traversing a matrix from column n-1` `class` `GFG {` `    ``// Function used for traversing over the given matrix``    ``static` `void` `traverseMatrix(``int``[][] mat, ``int` `n)``    ``{` `        ``// Initial cell coordinates``        ``int` `cur_x = ``0``, cur_y = n - ``1``;` `        ``// Variable used for keeping track of last move``        ``String prev_move = ``""``;` `        ``// Variable used for keeping count``        ``// of cells traversed till next move``        ``int` `move_cnt = ``1``;``        ``int` `cell_cnt = ``1``;``        ``System.out.print(Integer.toString(``                             ``mat[cur_x][cur_y])``                         ``+ ``" "``);` `        ``while` `(cell_cnt < n * n) {` `            ``// odd numbered move``            ``// [SINGLE VERTICAL/HORIZONTAL]``            ``if` `(move_cnt % ``2` `== ``1``) {``                ``// last move was made in north east direction``                ``if` `(prev_move == ``"NORTH_WEST"` `|| prev_move == ``""``) {``                    ``// move left``                    ``if` `(cur_y != ``0``) {``                        ``--cur_y;``                        ``prev_move = ``"LEFT"``;``                    ``}``                    ``// move down``                    ``else` `{``                        ``++cur_x;``                        ``prev_move = ``"DOWN"``;``                    ``}``                ``}` `                ``// last move was made in south east direction``                ``else` `{` `                    ``// move down``                    ``if` `(cur_x != n - ``1``) {``                        ``++cur_x;``                        ``prev_move = ``"DOWN"``;``                    ``}` `                    ``// move left``                    ``else` `{``                        ``--cur_y;``                        ``prev_move = ``"LEFT"``;``                    ``}``                ``}``                ``System.out.print(Integer.toString(``                                     ``mat[cur_x][cur_y])``                                 ``+ ``" "``);``                ``++cell_cnt;``            ``}` `            ``// even numbered move/s [DIAGONAL/S]``            ``else` `{``                ``if` `((move_cnt >> ``1``) % ``2` `== ``1``) {` `                    ``// move south east``                    ``while` `(cur_x < n - ``1` `&& cur_y < n - ``1``) {``                        ``++cur_x;``                        ``++cur_y;``                        ``prev_move = ``"SOUTH_EAST"``;``                        ``System.out.print(``                            ``Integer.toString(``                                ``mat[cur_x][cur_y])``                            ``+ ``" "``);``                        ``++cell_cnt;``                    ``}``                ``}``                ``else` `{` `                    ``// move north west``                    ``while` `(cur_x > ``0` `&& cur_y > ``0``) {``                        ``--cur_x;``                        ``--cur_y;``                        ``prev_move = ``"NORTH_WEST"``;``                        ``System.out.print(``                            ``Integer.toString(``                                ``mat[cur_x][cur_y])``                            ``+ ``" "``);``                        ``++cell_cnt;``                    ``}``                ``}``            ``}``            ``++move_cnt;``        ``}``    ``}` `    ``// Driver function``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// number of rows and columns``        ``int` `n = ``5``;` `        ``// 5x5 matrix``        ``int``[][] mat = {``            ``{ ``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` `}``        ``};` `        ``traverseMatrix(mat, n);` `        ``System.exit(``0``);``    ``}``}`

Python]

``````
// CSHARP program for traversing a matrix from column n-1

using System;
using System.Linq;

class GFG {

// Function used for traversing over the given matrix
static void traverseMatrix(int[, ] mat, int n)
{

// Initial cell coordinates
int cur_x = 0, cur_y = n - 1;

// Variable used for keeping track of last move
string prev_move = "";

// Variable used for keeping count
// of cells traversed till next move
int move_cnt = 1;
int cell_cnt = 1;
Console.Write(mat[cur_x, cur_y].ToString() + " ");

while (cell_cnt < n * n) {

// odd numbered move [SINGLE VERTICAL/HORIZONTAL]
if (move_cnt % 2 == 1) {

// last move was made in north east direction
if (prev_move == "NORTH_WEST" || prev_move == "") {

// move left
if (cur_y != 0) {
--cur_y;
prev_move = "LEFT";
}

// move down
else {
++cur_x;
prev_move = "DOWN";
}
}

// last move was made in south east direction
else {
// move down
if (cur_x != n - 1) {
++cur_x;
prev_move = "DOWN";
}
// move left
else {
--cur_y;
prev_move = "LEFT";
}
}
Console.Write(
mat[cur_x, cur_y].ToString() + " ");
++cell_cnt;
}

// even numbered move/s [DIAGONAL/S]
else {
if ((move_cnt >> 1) % 2 == 1) {

// Console.WriteLine("[...]");
// move south east
while (cur_x < n - 1 && cur_y < n - 1) {
++cur_x;
++cur_y;
prev_move = "SOUTH_EAST";
Console.Write(
mat[cur_x, cur_y].ToString()
+ " ");
++cell_cnt;
}
}
else {

// move north west
while (cur_x > 0 && cur_y > 0) {
--cur_x;
--cur_y;
prev_move = "NORTH_WEST";
Console.Write(
mat[cur_x, cur_y].ToString()
+ " ");
++cell_cnt;
}
}
}
++move_cnt;
}
}

// Driver function
public static void Main()
{

// number of rows and columns
int n = 5;

// 5x5 matrix
int[, ] mat = {
{ 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 }
};

traverseMatrix(mat, n);
}
}
``````

## PHP

 `> 1) & 1) {` `                ``# move south east``                ``while` `(``\$cur_x` `< ``\$n` `- 1 ``and` `\$cur_y` `< ``\$n` `- 1) {``                    ``\$cur_x` `+= 1; ``\$cur_y` `+= 1;``                    ``\$prev_move` `= ``"SOUTH_EAST"``;``                    ``print``(``\$mat``[``\$cur_x``][``\$cur_y``].``" "``);``                    ``\$cell_cnt` `+= 1;``                ``}``            ``}``                ` `            ``else` `{` `                ``# move north west``                ``while``(``\$cur_x` `> 0 ``and` `\$cur_y` `> 0) {``                    ``\$cur_x` `-=1 ; ``\$cur_y` `-= 1;``                    ``\$prev_move` `= ``"NORTH_WEST"``;``                    ``print``(``\$mat``[``\$cur_x``][``\$cur_y``].``" "``);``                    ``\$cell_cnt` `+= 1;``                ``}``            ``}``        ``}``                ` `        ``\$move_cnt` `+= 1;``    ``}``}`  `// Driver function` `# number of rows ``and` `columns``\$n` `= 5;` `#  5x5 matrix``\$mat` `= ``array``(``     ``array``(1,  2,  3,  4,  5),``     ``array``(6,  7,  8,  9,  10),``     ``array``(11, 12, 13, 14, 15),``     ``array``(16, 17, 18, 19, 20),``     ``array``(21, 22, 23, 24, 25)``);` `traverseMatrix(``\$mat``, ``\$n``);``?>`

Output

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

Complexity Analysis:

• Time Complexity: O(N^2)
• Space Complexity: O(1)

My Personal Notes arrow_drop_up