Zigzag (or diagonal) traversal of Matrix

20 Jun, 2022
Given a 2D matrix, print all elements of the given matrix in diagonal order. For example, consider the following 5 X 4 input matrix.  
Example:
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: 
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. 
Implementation:
C++
C
Java
Python3
C#
PHP
Javascript
// C++ program to print all elements// of given matrix in diagonal order#include <bits/stdc++.h>using namespace std; #define ROW 5#define COL 4 // A utility function to find min// of two integersint minu(int a, int b){    return (a < b) ? a : b;} // A utility function to find min// of three integersint min(int a, int b, int c){    return minu(minu(a, b), c);} // A utility function to find// max of two integersint max(int a, int b){    return (a > b) ? a : b;} // The main function that prints given// matrix in diagonal ordervoid 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 < count; j++)            cout << setw(5) <<            matrix[minu(ROW, line) - j - 1][start_col + j];         /* Print elements of next           diagonal on next line */        cout << "\n";    }} // Utility function to print a matrixvoid printMatrix(int matrix[ROW][COL]){    for(int i = 0; i < ROW; i++)    {        for(int j = 0; j < COL; j++)            cout << setw(5) << matrix[i][j];                     cout << "\n";    }} // Driver codeint main(){    int M[ROW][COL] = { { 1, 2, 3, 4 },                        { 5, 6, 7, 8 },                        { 9, 10, 11, 12 },                        { 13, 14, 15, 16 },                        { 17, 18, 19, 20 },};    cout << "Given matrix is " << endl;    printMatrix(M);     cout << "\nDiagonal printing of matrix is " << endl;    diagonalOrder(M);    return 0;} // This code is contributed by shubhamsingh10
// C program to print all elements// of given matrix in diagonal order#include <stdlib.h> #define ROW 5#define COL 4 // A utility function to find min of two integersint minu(int a, int b){ return (a < b)? a: b; } // A utility function to find min of three integersint min(int a, int b, int c){ return minu(minu(a, b), c);} // A utility function to find max of two integersint max(int a, int b){ return (a > b)? a: b; } // The main function that prints given matrix in// diagonal ordervoid 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<count; j++)            printf("%5d ",                   matrix[minu(ROW, line)-j-1][start_col+j]);         /* Print elements of next diagonal on next line */        printf("\n");    }} // Utility function to print a matrixvoid printMatrix(int matrix[ROW][COL]){    for (int i=0; i< ROW; i++)    {        for (int j=0; j<COL; j++)            printf("%5d ", matrix[i][j]);        printf("\n");    }} // Driver codeint main(){    int M[ROW][COL] = {{1, 2, 3, 4},                       {5, 6, 7, 8},                       {9, 10, 11, 12},                       {13, 14, 15, 16},                       {17, 18, 19, 20},                      };    printf ("Given matrix is \n");    printMatrix(M);     printf ("\nDiagonal printing of matrix is \n");    diagonalOrder(M);    return 0;}
// Java program to print all elements// of given matrix in diagonal orderclass 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 program to print all elements# of given matrix in diagonal orderROW = 5COL = 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 matrixdef printMatrix(matrix):    for i in range(0, ROW):        for j in range(0, COL):            print(matrix[i][j], end="\t")         print()  # Driver CodeM = [[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# program to print all elements// of given matrix in diagonal orderusing System;using static System.Math; 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 = 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, Math.Min((COL - start_col), ROW));             // Print elements of this line            for (int j = 0; j < count; j++)                Console.Write(matrix[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// PHP Code for Zigzag (or diagonal)// traversal of Matrix$ROW = 5;$COL = 4; // The main function that prints// given matrix in diagonal orderfunction diagonalOrder(&$matrix){    global $ROW, $COL;         // There will be ROW+COL-1    // lines in the output    for ($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 */        $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 = 0; $j < $count; $j++)        {            echo $matrix[min($ROW, $line) -                 $j - 1][$start_col + $j];            echo "\t";        }         /* Print elements of next           diagonal on next line */        print("\n");    }} // Utility function// to print a matrixfunction printMatrix(&$matrix){    global $ROW, $COL;    for ($i = 0; $i < $ROW; $i++)    {        for ($j = 0; $j < $COL; $j++)        {            echo $matrix[$i][$j] ;            echo "\t";        }        print("\n");    }} // Driver Code$M = 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));echo "Given matrix is \n";printMatrix($M); printf ("\nDiagonal printing " .        "of matrix is \n");diagonalOrder($M); // This code is contributed// by ChitraNayal?>
<script>// Javascript program to print all elements// of given matrix in diagonal order let ROW = 5;let COL = 4; // A utility function to find min    // of two integersfunction min(a, b){    return (a < b) ? a : b;} // A utility function to find min    // of three integerfunction _min(a, b, c){    return min(min(a, b), c);} // A utility function to find max    // of two integersfunction max(a,b){    return (a > b) ? a : b;} // The main function that prints given    // matrix in diagonal orderfunction diagonalOrder(matrix){    // There will be ROW+COL-1 lines in the output        for (let 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            let 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            let count = min(line, (COL - start_col),                            ROW);              // Print elements of this line            for (let j = 0; j < count; j++)                document.write(matrix[min(ROW, line)                                        - j- 1][start_col + j]                                 + " ");              // Print elements of next diagonal on next line            document.write("<br>");        }} // Utility function to print a matrixfunction printMatrix(matrix){    for (let i = 0; i < ROW; i++)        {            for (let j = 0; j < COL; j++)                document.write(matrix[i][j] + " ");            document.write("<br>");        }} // Driver codelet M = [[ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ],            [ 9, 10, 11, 12 ],  [ 13, 14, 15, 16 ],            [ 17, 18, 19, 20 ]];document.write("Given matrix is <br>");printMatrix(M); document.write("<br>Diagonal printing of matrix is <br>");diagonalOrder(M); // This code is contributed by ab2127</script>
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 
Time Complexity: O(row x col) Auxiliary Space: O(1)
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
Implementation:
C++
Java
Python3
C#
PHP
Javascript
#include <bits/stdc++.h>#define R 5#define C 4using 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[0][0], arr[1][0]....arr[R-1][0]    are all starting points */    for (int k = 0; k < R; k++)    {        cout << arr[k][0] << " ";               // set row index for next point in        // diagonal        int i = k - 1;                // set column index for next point in        //    diagonal        int j = 1;         /* Print Diagonally upward */        while (isValid(i, j)) {            cout << arr[i][j] << " ";            i--;                       // move in upright direction            j++;        }        cout << endl;    }     /* through this for loop we choose       each element of last row as starting       point (except the [0][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++)    {        cout << arr[R - 1][k] << " ";               // set row index for next point in        // diagonal        int i = R - 2;                 // set column index for next point in        // diagonal        int j = k + 1;         /* Print Diagonally upward */        while (isValid(i, j))        {            cout << arr[i][j] << " ";            i--;                       // move in upright direction            j++;        }        cout << endl;    }} // Driver Codeint 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 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[0][0],        arr[1][0]....arr[R-1][0] are all starting points */        for (int k = 0; k < R; k++) {            System.out.print(arr[k][0] + " ");             // set row index for next            // point in diagonal            int i = k - 1;                       //  set column index for            // next point in diagonal            int j = 1;             /* Print Diagonally upward */            while (isValid(i, j))            {                System.out.print(arr[i][j] + " ");                 i--;                                // move in upright direction                j++;            }             System.out.println("");        }         /* through this for loop we choose each element           of last row as starting point (except the           [0][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++) {            System.out.print(arr[R - 1][k] + " ");             // set row index for next            // point in diagonal            int i = R - 2;                       // set column index for            // next point in diagonal            int j = k + 1;             /* Print Diagonally upward */            while (isValid(i, j))            {                System.out.print(arr[i][j] + " ");                 // move in upright direction                i--;                j++;            }             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 code    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;         // Function call        diagonalOrder(arr);    }} // This code is contributed by Arnav Kr. Mandal.
# Python3 program to print all elements# of given matrix in diagonal orderR = 5C = 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[0][0], arr[1][0]....arr[R-1][0]    # 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 [0][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 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 Codearr = [[1, 2, 3, 4],       [5, 6, 7, 8],       [9, 10, 11, 12],       [13, 14, 15, 16],       [17, 18, 19, 20]] # Function calldiagonalOrder(arr) # This code is contributed by Nikita Tiwari.
// C# Code for Zigzag (or diagonal)// traversal of Matrixusing 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] + " ");             // set row index for next            // point in diagonal            int i = k - 1;                       // set column index for            // next point in diagonal            int j = 1;             /* Print Diagonally upward */            while (isValid(i, j))            {                Console.Write(arr[i, j] + " ");                 i--;                               // move in upright direction                j++;            }             Console.Write("\n");        }         /*  through this for loop we            choose each element of last            row as starting point (except            the [0][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] + " ");             // set row index for next            // point in diagonal            int i = R - 2;                       // set column index for            // next point in diagonal            int j = k + 1;             /* 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);         // Function call        diagonalOrder(arr);    }} // This code is contributed// by ChitraNayal
<?php// PHP code for Zigzag (or diagonal)// traversal of Matrixdefine("R", 5);define("C", 4); function isValid($i, $j){    if ($i < 0 || $i >= 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[0][0], arr[1][0]....arr[R-1][0]    are all starting points */    for ($k = 0; $k < R; $k++)    {        echo $arr[$k][0] . " ";        $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 [0][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 ($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)); // Function calldiagonalOrder($arr); // This code is contributed// by rathbhupendra?>
<script>// JAVA Code for Zigzag (or diagonal)// traversal of Matrix var R, C;     function diagonalOrder( 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 (var k = 0; k < R; k++) {            document.write(arr[k][0] + " ");             // set row index for next            // point in diagonal            var i = k - 1;                       //  set column index for            // next point in diagonal            var j = 1;             /* Print Diagonally upward */            while (isValid(i, j))            {                document.write(arr[i][j] + " ");                 i--;                                // move in upright direction                j++;            }             document.writeln("<br>");        }         /* through this for loop we choose each element           of last row as starting point (except the           [0][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 (var k = 1; k < C; k++) {            document.write(arr[R - 1][k] + " ");             // set row index for next            // point in diagonal            var i = R - 2;                       // set column index for            // next point in diagonal            var j = k + 1;             /* Print Diagonally upward */            while (isValid(i, j))            {                document.write(arr[i][j] + " ");                 // move in upright direction                i--;                j++;            }             document.writeln("<br>");        }    }     function isValid( i,  j)    {        if (i < 0 || i >= R            || j >= C || j < 0)            return false;        return true;    }     // Driver code            var 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;         // Function call        diagonalOrder(arr); // This code is contributed by shivanisinghss2110</script>
1 
5 2 
9 6 3 
13 10 7 4 
17 14 11 8 
18 15 12 
19 16 
20 
Time Complexity: O(row x col) Auxiliary Space: O(1)
Thanks to Gaurav Ahirwar for suggesting this method. 
Print matrix in antispiral form
Print matrix in spiral form
Print a given matrix in zigzag form
This article is compiled by Ashish Anand and reviewed by GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
It’s a keen observation that the sum of [i+j] that is the indexes of the array remains the same throughout the diagonal. So we will exploit this property of the matrix to make our code short and simple.
Below is the implementation of the above idea:
C++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>#define R 5#define C 4using namespace std; void diagonalOrder(int arr[][C],                   int n, int m){    // we will use a 2D vector to    // store the diagonals of our array    // the 2D vector will have (n+m-1)    // rows that is equal to the number of    // diagonals    vector<vector<int> > ans(n + m - 1);     for (int i = 0; i < m; i++)    {        for (int j = 0; j < n; j++)        {            ans[i + j].push_back(arr[j][i]);        }    }     for (int i = 0; i < ans.size(); i++)    {        for (int j = 0; j < ans[i].size(); j++)            cout << ans[i][j] << " ";         cout << endl;    }} // Driver Codeint main(){    // we have a matrix of n rows    // and m columns    int n = 5, m = 4;    int arr[][C] = {        { 1, 2, 3, 4 },        { 5, 6, 7, 8 },        { 9, 10, 11, 12 },        { 13, 14, 15, 16 },        { 17, 18, 19, 20 },    };        // Function call    diagonalOrder(arr, n, m);    return 0;}
import java.util.*;import java.io.*; class GFG{  public static int R = 5, C = 4;  public static void diagonalOrder(int[][] arr, int n, int m)  {     // we will use a 2D vector to    // store the diagonals of our array    // the 2D vector will have (n+m-1)    // rows that is equal to the number of    // diagonals    ArrayList<ArrayList<Integer>> ans = new ArrayList<ArrayList<Integer>>(n+m-1);    for(int i = 0; i < n + m - 1; i++)    {      ans.add(new ArrayList<Integer>());    }     for (int i = 0; i < n; i++)    {      for (int j = 0; j < m; j++)      {        (ans.get(i+j)).add(arr[i][j]);      }    }     for (int i = 0; i < ans.size(); i++)    {      for (int j = ans.get(i).size() - 1; j >= 0; j--)      {    System.out.print(ans.get(i).get(j)+ " ");      }        System.out.println();    }  }   // Driver code  public static void main (String[] args) {    int n = 5, m = 4;    int[][] arr={      { 1, 2, 3, 4 },      { 5, 6, 7, 8 },      { 9, 10, 11, 12 },      { 13, 14, 15, 16 },      { 17, 18, 19, 20 },    };     // Function call    diagonalOrder(arr, n, m);  }} // This code is contributed by Manu Pathria
R = 5C = 5def diagonalOrder(arr, n, m):         # we will use a 2D vector to    # store the diagonals of our array    # the 2D vector will have (n+m-1)    # rows that is equal to the number of    # diagonals    ans = [[] for i in range(n + m - 1)]         for i in range(m):        for j in range(n):            ans[i + j].append(arr[j][i])         for i in range(len(ans)):        for j in range(len(ans[i])):            print(ans[i][j], end = " ")        print() # Driver Code# we have a matrix of n rows# and m columnsn = 5m = 4 # Function callarr = [[1, 2, 3, 4],[ 5, 6, 7, 8],[9, 10, 11, 12 ],[13, 14, 15, 16 ],[ 17, 18, 19, 20]]diagonalOrder(arr, n, m) # This code is contributed by rag2127
using System;using System.Collections.Generic; public class GFG{   public static int R = 5, C = 4;  public static void diagonalOrder(int[,] arr, int n, int m)  {     // we will use a 2D vector to    // store the diagonals of our array    // the 2D vector will have (n+m-1)    // rows that is equal to the number of    // diagonals    List<List<int>> ans = new List<List<int>>(n+m-1);    for(int i = 0; i < n + m - 1; i++)    {      ans.Add(new List<int>());    }     for (int i = 0; i < n; i++)    {      for (int j = 0; j < m; j++)      {        (ans[i + j]).Add(arr[i, j]);      }    }     for (int i = 0; i < ans.Count; i++)    {      for (int j = ans[i].Count - 1; j >= 0; j--)      {           Console.Write(ans[i][j] + " ");      }        Console.WriteLine();    }   }  // Driver code  static public void Main ()  {    int n = 5, m = 4;    int[,] arr={      { 1, 2, 3, 4 },      { 5, 6, 7, 8 },      { 9, 10, 11, 12 },      { 13, 14, 15, 16 },      { 17, 18, 19, 20 },    };     // Function call    diagonalOrder(arr, n, m);  }} // This code is contributed by avanitrachhadiya2155
<script> var R = 5;var C = 4; function diagonalOrder(arr, n, m){    // we will use a 2D vector to    // store the diagonals of our array    // the 2D vector will have (n+m-1)    // rows that is equal to the number of    // diagonals    var ans = Array.from(Array(n+m-1), ()=>Array());     for (var i = 0; i < n; i++)    {        for (var j = 0; j < m; j++)        {            ans[i + j].push(arr[i][j]);        }    }     for (var i = 0; i < ans.length; i++)    {      for (var j = ans[i].length - 1; j >= 0; j--)      {           document.write(ans[i][j] + " ");      }        document.write("<br>");    }} // Driver Code// we have a matrix of n rows// and m columnsvar n = 5, m = 4;var arr = [    [ 1, 2, 3, 4 ],    [ 5, 6, 7, 8 ],    [ 9, 10, 11, 12 ],    [ 13, 14, 15, 16 ],    [ 17, 18, 19, 20 ],]; // Function calldiagonalOrder(arr, n, m); // This code is contributed by rrrtnx.</script>
1 
5 2 
9 6 3 
13 10 7 4 
17 14 11 8 
18 15 12 
19 16 
20 
 Time Complexity: O(row x col) Auxiliary Space: O(row + col)
ukasp
rathbhupendra
ShubhamAgarwal23
red_devil09
manupathria
avanitrachhadiya2155
rag2127
SHUBHAMSINGH10
ab2127
gabaa406
shivanisinghss2110
rrrtnx
arorakashish0911
sachinvinod1904
hardikkoriintern
Amazon
pattern-printing
Matrix
Misc
Amazon
Misc
pattern-printing
Misc
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Sudoku | Backtracking-7
The Celebrity Problem
Rotate a matrix by 90 degree in clockwise direction without using any extra space
Maximum size rectangle binary sub-matrix with all 1s
Inplace rotate square matrix by 90 degrees | Set 1
Overview of Data Structures | Set 1 (Linear Data Structures)
vector::push_back() and vector::pop_back() in C++ STL
Top 10 algorithms in Interview Questions
Virtualization In Cloud Computing and Types
How to write Regular Expressions?