Elements of anti diagonal in python assignment expert

View Discussion

Improve Article

Save Article

View Discussion

Improve Article

Save Article

Given a square matrix of size N*N, return an array of its anti-diagonals. For better understanding let us look at the image given below:

Examples: 

Input :

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

Approach 1:
To solve the problem mentioned above we have two major observations. 

• The first one is, some diagonals start from the zeroth row for each column and ends when either start column >= 0 or start row < N.
• While the second observation is that the remaining diagonals start with end column for each row and ends when either start row < N or start column >= 0.

Below is the implementation of the above approach: 

C++

#include

using namespace std;

void diagonal(int A[3][3])

{

    int N = 3;

    for (int col = 0; col < N; col++) {

        int startcol = col, startrow = 0;

        while (startcol >= 0 && startrow < N) {

            cout << A[startrow][startcol] << " ";

            startcol--;

            startrow++;

        }

        cout << "\n";

    }

    for (int row = 1; row < N; row++) {

        int startrow = row, startcol = N - 1;

        while (startrow < N && startcol >= 0) {

            cout << A[startrow][startcol] << " ";

            startcol--;

            startrow++;

        }

        cout << "\n";

    }

}

int main()

{

    int A[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

    diagonal(A);

    return 0;

}

Java

class Matrix {

    void diagonal(int A[][])

    {

        int N = 3;

        for (int col = 0; col < N; col++) {

            int startcol = col, startrow = 0;

            while (startcol >= 0 && startrow < N) {

                System.out.print(A[startrow][startcol]

                                 + " ");

                startcol--;

                startrow++;

            }

            System.out.println();

        }

        for (int row = 1; row < N; row++) {

            int startrow = row, startcol = N - 1;

            while (startrow < N && startcol >= 0) {

                System.out.print(A[startrow][startcol]

                                 + " ");

                startcol--;

                startrow++;

            }

            System.out.println();

        }

    }

    public static void main(String args[])

    {

        int A[][]

            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        Matrix m = new Matrix();

        m.diagonal(A);

    }

}

Python3

def diagonal(A):

    N = 3

    for col in range(N):

        startcol = col

        startrow = 0

        while(startcol >= 0 and

              startrow < N):

            print(A[startrow][startcol], end = " ")

            startcol -= 1

            startrow += 1

        print()

    for row in range(1, N):

        startrow = row

        startcol = N - 1

        while(startrow < N and

              startcol >= 0):

            print(A[startrow][startcol],

                  end=" ")

            startcol -= 1

            startrow += 1

        print()

if __name__ == "__main__":

    A = [[1, 2, 3],

         [4, 5, 6],

         [7, 8, 9]]

    diagonal(A)

C#

using System;

class GFG {

    static void diagonal(int[, ] A)

    {

        int N = 3;

        for (int col = 0; col < N; col++) {

            int startcol = col, startrow = 0;

            while (startcol >= 0 && startrow < N) {

                Console.Write(A[startrow, startcol] + " ");

                startcol--;

                startrow++;

            }

            Console.WriteLine();

        }

        for (int row = 1; row < N; row++) {

            int startrow = row, startcol = N - 1;

            while (startrow < N && startcol >= 0) {

                Console.Write(A[startrow, startcol] + " ");

                startcol--;

                startrow++;

            }

            Console.WriteLine();

        }

    }

    public static void Main(string[] args)

    {

        int[, ] A

            = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

        diagonal(A);

    }

}

Javascript