Open In App

Program to print the Diagonals of a Matrix

Last Updated : 09 Oct, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

Given a 2D square matrix, print the Principal and Secondary diagonals. 

Examples : 

Input: 
4
1 2 3 4
4 3 2 1
7 8 9 6
6 5 4 3
Output:
Principal Diagonal: 1, 3, 9, 3
Secondary Diagonal: 4, 2, 8, 6
Input:
3
1 1 1
1 1 1
1 1 1
Output:
Principal Diagonal: 1, 1, 1
Secondary Diagonal: 1, 1, 1

For example, consider the following 4 X 4 input matrix. 

A00 A01 A02 A03
A10 A11 A12 A13
A20 A21 A22 A23
A30 A31 A32 A33

  • The primary diagonal is formed by the elements A00, A11, A22, A33.
    Condition for Principal Diagonal:
The row-column condition is row = column.

  • The secondary diagonal is formed by the elements A03, A12, A21, A30. 
    Condition for Secondary Diagonal:
The row-column condition is row = numberOfRows - column -1.

Method 1: 
In this method, we use two loops i.e. a loop for columns and a loop for rows and in the inner loop we check for the condition stated above.

C++




// C++ Program to print the Diagonals of a Matrix
 
#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 100;
 
// Function to print the Principal Diagonal
void printPrincipalDiagonal(int mat[][MAX], int n)
{
    cout << "Principal Diagonal: ";
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
 
            // Condition for principal diagonal
            if (i == j)
                cout << mat[i][j] << ", ";
        }
    }
    cout << endl;
}
 
// Function to print the Secondary Diagonal
void printSecondaryDiagonal(int mat[][MAX], int n)
{
    cout << "Secondary Diagonal: ";
 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
 
            // Condition for secondary diagonal
            if ((i + j) == (n - 1))
                cout << mat[i][j] << ", ";
        }
    }
    cout << endl;
}
 
// Driver code
int main()
{
    int n = 4;
    int a[][MAX] = { { 1, 2, 3, 4 },
                     { 5, 6, 7, 8 },
                     { 1, 2, 3, 4 },
                     { 5, 6, 7, 8 } };
 
    printPrincipalDiagonal(a, n);
    printSecondaryDiagonal(a, n);
    return 0;
}


Java




// Java Program to print the Diagonals of a Matrix
class GFG {
    static int MAX = 100;
 
    // Function to print the Principal Diagonal
    static void printPrincipalDiagonal(int mat[][], int n)
    {
        System.out.print("Principal Diagonal: ");
 
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
 
                // Condition for principal diagonal
                if (i == j) {
                    System.out.print(mat[i][j] + ", ");
                }
            }
        }
        System.out.println("");
    }
 
    // Function to print the Secondary Diagonal
    static void printSecondaryDiagonal(int mat[][], int n)
    {
        System.out.print("Secondary Diagonal: ");
 
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
 
                // Condition for secondary diagonal
                if ((i + j) == (n - 1)) {
                    System.out.print(mat[i][j] + ", ");
                }
            }
        }
        System.out.println("");
    }
 
    // Driver code
    public static void main(String args[])
    {
        int n = 4;
        int a[][] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 } };
 
        printPrincipalDiagonal(a, n);
        printSecondaryDiagonal(a, n);
    }
}
 
// This code is contributed by Rajput-Ji


Python3




# Python3 Program to print the Diagonals of a Matrix
MAX = 100
 
# Function to print the Principal Diagonal
def printPrincipalDiagonal(mat, n):
    print("Principal Diagonal: ", end = "")
 
    for i in range(n):
        for j in range(n):
 
            # Condition for principal diagonal
            if (i == j):
                print(mat[i][j], end = ", ")
    print()
 
# Function to print the Secondary Diagonal
def printSecondaryDiagonal(mat, n):
    print("Secondary Diagonal: ", end = "")
 
    for i in range(n):
        for j in range(n):
 
            # Condition for secondary diagonal
            if ((i + j) == (n - 1)):
                print(mat[i][j], end = ", ")
    print()
 
# Driver code
n = 4
a = [[ 1, 2, 3, 4 ],
     [ 5, 6, 7, 8 ],
     [ 1, 2, 3, 4 ],
     [ 5, 6, 7, 8 ]]
 
printPrincipalDiagonal(a, n)
printSecondaryDiagonal(a, n)
 
# This code is contributed by Mohit Kumar


C#




// C# Program to print the Diagonals of a Matrix
using System;
 
class GFG {
    static int MAX = 100;
 
    // Function to print the Principal Diagonal
    static void printPrincipalDiagonal(int[, ] mat, int n)
    {
        Console.Write("Principal Diagonal: ");
 
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
 
                // Condition for principal diagonal
                if (i == j) {
                    Console.Write(mat[i, j] + ", ");
                }
            }
        }
        Console.WriteLine("");
    }
 
    // Function to print the Secondary Diagonal
    static void printSecondaryDiagonal(int[, ] mat, int n)
    {
        Console.Write("Secondary Diagonal: ");
 
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
 
                // Condition for secondary diagonal
                if ((i + j) == (n - 1)) {
                    Console.Write(mat[i, j] + ", ");
                }
            }
        }
        Console.WriteLine("");
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int n = 4;
        int[, ] a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 } };
 
        printPrincipalDiagonal(a, n);
        printSecondaryDiagonal(a, n);
    }
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
 
    // Javascript Program to print the Diagonals of a Matrix
     
    let MAX = 100;
  
    // Function to print the Principal Diagonal
    function printPrincipalDiagonal(mat, n)
    {
        document.write("Principal Diagonal: ");
  
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < n; j++) {
  
                // Condition for principal diagonal
                if (i == j) {
                    document.write(mat[i][j] + ", ");
                }
            }
        }
        document.write("</br>");
    }
  
    // Function to print the Secondary Diagonal
    function printSecondaryDiagonal(mat, n)
    {
        document.write("Secondary Diagonal: ");
  
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < n; j++) {
  
                // Condition for secondary diagonal
                if ((i + j) == (n - 1)) {
                    document.write(mat[i][j] + ", ");
                }
            }
        }
        document.write("</br>");
    }
     
    let n = 4;
    let a = [ [ 1, 2, 3, 4 ],
              [ 5, 6, 7, 8 ],
              [ 1, 2, 3, 4 ],
              [ 5, 6, 7, 8 ] ];
 
    printPrincipalDiagonal(a, n);
    printSecondaryDiagonal(a, n);
     
</script>


Output

Principal Diagonal: 1, 6, 3, 8, 
Secondary Diagonal: 4, 7, 2, 5,





Complexity Analysis:  

  • Time Complexity: O(n2). 
    As there is a nested loop involved so the time complexity is squared.
  • Auxiliary Space: O(1). 
    As no extra space is occupied.

Method 2: 
In this method, the same condition for printing the diagonal elements can be achieved using a single for loop. 
Approach: 

  1. For Principal Diagonal elements: Run a for a loop until n, where n is the number of columns, and print array[i][i] where i is the index variable.
  2. For Secondary Diagonal elements: Run a for a loop until n, where n is the number of columns and print array[i][k] where i is the index variable and k = array_length – 1. Decrease k until i < n.

Below is the implementation of the above approach. 
 

C++




// C++ Program to print the Diagonals of a Matrix
 
#include <bits/stdc++.h>
using namespace std;
 
const int MAX = 100;
 
// Function to print the Principal Diagonal
void printPrincipalDiagonal(int mat[][MAX], int n)
{
    cout << "Principal Diagonal: ";
 
    for (int i = 0; i < n; i++) {
        // Printing principal diagonal
        cout << mat[i][i] << ", ";
    }
    cout << endl;
}
 
// Function to print the Secondary Diagonal
void printSecondaryDiagonal(int mat[][MAX], int n)
{
    cout << "Secondary Diagonal: ";
    int k = n - 1;
    for (int i = 0; i < n; i++) {
        // Printing secondary diagonal
        cout << mat[i][k--] << ", ";
    }
    cout << endl;
}
 
// Driver code
int main()
{
    int n = 4;
    int a[][MAX] = { { 1, 2, 3, 4 },
                     { 5, 6, 7, 8 },
                     { 1, 2, 3, 4 },
                     { 5, 6, 7, 8 } };
 
    printPrincipalDiagonal(a, n);
    printSecondaryDiagonal(a, n);
    return 0;
}
 
// This code is contributed by yashbeersingh42


Java




// Java Program to print the
// Diagonals of a Matrix
class Main{
   
static int MAX = 100;
     
// Function to print the Principal Diagonal
public static void printPrincipalDiagonal(int mat[][],
                                          int n)
{
  System.out.print("Principal Diagonal: ");
 
  for (int i = 0; i < n; i++)
  {
    // Printing principal diagonal
    System.out.print(mat[i][i] + ", ");
  }
  System.out.println();
}
 
// Function to print the Secondary Diagonal
public static void printSecondaryDiagonal(int mat[][],
                                          int n)
{
  System.out.print("Secondary Diagonal: ");
  int k = n - 1;
   
  for (int i = 0; i < n; i++)
  {
    // Printing secondary diagonal
    System.out.print(mat[i][k--] + ", ");
  }
  System.out.println();
}
 
public static void main(String[] args)
{
  int n = 4;
  int a[][] = {{1, 2, 3, 4},
               {5, 6, 7, 8},
               {1, 2, 3, 4},
               {5, 6, 7, 8}};
  printPrincipalDiagonal(a, n);
  printSecondaryDiagonal(a, n);
}
}
 
// This code is contributed by divyeshrabadiya07


Python3




# Python3 program to print the
# Diagonals of a Matrix
MAX = 100
 
# Function to print the Principal Diagonal
def printPrincipalDiagonal(mat, n):
 
    print("Principal Diagonal: ", end = "")
 
    for i in range(n):
         
        # Printing principal diagonal
        print(mat[i][i], end = ", ")
 
    print()
 
# Function to print the Secondary Diagonal
def printSecondaryDiagonal(mat, n):
 
    print("Secondary Diagonal: ", end = "")
    k = n - 1
     
    for i in range(n):
         
        # Printing secondary diagonal
        print(mat[i][k], end = ", ")
        k -= 1
 
    print()
     
# Driver Code
n = 4
a = [ [ 1, 2, 3, 4 ],
      [ 5, 6, 7, 8 ],
      [ 1, 2, 3, 4 ],
      [ 5, 6, 7, 8 ] ]
 
printPrincipalDiagonal(a, n)
printSecondaryDiagonal(a, n)
 
# This code is contributed by divyesh072019


C#




// C# program for the
// above approach
using System;
class GFG{
     
// Function to print the
// Principal Diagonal
static void printPrincipalDiagonal(int [,]mat,
                                   int n)
{
  Console.Write("Principal Diagonal: ");
 
  for (int i = 0; i < n; i++)
  {
    // Printing principal diagonal
    Console.Write(mat[i, i] + ", ");
  }
  Console.Write("\n");
}
  
// Function to print the
// Secondary Diagonal
static void printSecondaryDiagonal(int [,]mat,
                                   int n)
{
  Console.Write("Secondary Diagonal: ");
  int k = n - 1;
   
  for (int i = 0; i < n; i++)
  {
    // Printing secondary diagonal
    Console.Write(mat[i, k--] + ", ");
  }
   
  Console.Write("\n");
}
     
     
// Driver code
static void Main()
{
  int n = 4;
  int [,]a = {{1, 2, 3, 4},
              {5, 6, 7, 8},
              {1, 2, 3, 4},
              {5, 6, 7, 8}};
  printPrincipalDiagonal(a, n);
  printSecondaryDiagonal(a, n);
}
}
 
// This code is contributed by rutvik_56


Javascript




<script>
 
    // Javascript Program to print the
    // Diagonals of a Matrix
 
    let MAX = 100;
      
    // Function to print the Principal Diagonal
    function printPrincipalDiagonal(mat, n)
    {
      document.write("Principal Diagonal: ");
 
      for (let i = 0; i < n; i++)
      {
        // Printing principal diagonal
        document.write(mat[i][i] + ", ");
      }
      document.write("</br>");
    }
 
    // Function to print the Secondary Diagonal
    function printSecondaryDiagonal(mat, n)
    {
      document.write("Secondary Diagonal: ");
      let k = n - 1;
 
      for (let i = 0; i < n; i++)
      {
        // Printing secondary diagonal
        document.write(mat[i][k--] + ", ");
      }
      document.write("</br>");
    }
     
    let n = 4;
    let a = [[1, 2, 3, 4],
             [5, 6, 7, 8],
             [1, 2, 3, 4],
             [5, 6, 7, 8]];
    printPrincipalDiagonal(a, n);
    printSecondaryDiagonal(a, n);
     
</script>


Output

Principal Diagonal: 1, 6, 3, 8, 
Secondary Diagonal: 4, 7, 2, 5,





Complexity Analysis: 

  • Time Complexity: O(n). 
    As there is only one loop involved so the time complexity is linear.
  • Auxiliary Space: O(1). 
    As no extra space is occupied.

 Using list comprehensions:

Approach:

Define a function print_diagonals that takes a 2D list (matrix) as input.
Get the length of the matrix and store it in the variable n.
Use a list comprehension to create a list of the principal diagonal elements. To do this, iterate over the range from 0 to n and for each index i, append matrix[i][i] to the list principal.
Print the list of principal diagonal elements using the join() method to convert the list to a string separated by commas.
Use another list comprehension to create a list of the secondary diagonal elements. To do this, iterate over the range from 0 to n and for each index i, append matrix[i][n-1-i] to the list secondary.
Print the list of secondary diagonal elements using the join() method to convert the list to a string separated by commas.
Example usage: Create a 2D list matrix, call the print_diagonals function with matrix as input.

C++




#include <iostream>
#include <vector>
 
// Function to print the principal and secondary diagonals
// of a matrix
void printDiagonals(std::vector<std::vector<int> >& matrix)
{
    int n
        = matrix
              .size(); // Get the size of the square matrix
 
    // Get the principal diagonal
    std::vector<int> principal(n);
    for (int i = 0; i < n; i++) {
        principal[i] = matrix[i][i];
    }
 
    // Print the principal diagonal
    std::cout << "Principal Diagonal: ";
    for (int i = 0; i < n; i++) {
        std::cout << principal[i];
        if (i != n - 1) {
            std::cout << ", ";
        }
    }
    std::cout << std::endl;
 
    // Get the secondary diagonal
    std::vector<int> secondary(n);
    for (int i = 0; i < n; i++) {
        secondary[i] = matrix[i][n - 1 - i];
    }
 
    // Print the secondary diagonal
    std::cout << "Secondary Diagonal: ";
    for (int i = 0; i < n; i++) {
        std::cout << secondary[i];
        if (i != n - 1) {
            std::cout << ", ";
        }
    }
    std::cout << std::endl;
}
 
int main()
{
    std::vector<std::vector<int> > matrix
        = { { 1, 2, 3, 4 },
            { 4, 3, 2, 1 },
            { 7, 8, 9, 6 },
            { 6, 5, 4, 3 } };
 
    printDiagonals(matrix);
 
    return 0;
}


Java




import java.io.*;
public class GFG {
    public static void printDiagonals(int[][] matrix) {
        int n = matrix.length;
        // Get the principal diagonal
        int[] principal = new int[n];
        for (int i = 0; i < n; i++) {
            principal[i] = matrix[i][i];
        }
        System.out.print("Principal Diagonal: ");
        for (int i = 0; i < n; i++) {
            System.out.print(principal[i]);
            if (i != n - 1) {
                System.out.print(", ");
            }
        }
        System.out.println();
        // Get the secondary diagonal
        int[] secondary = new int[n];
        for (int i = 0; i < n; i++) {
            secondary[i] = matrix[i][n - 1 - i];
        }
        System.out.print("Secondary Diagonal: ");
        for (int i = 0; i < n; i++) {
            System.out.print(secondary[i]);
            if (i != n - 1) {
                System.out.print(", ");
            }
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3, 4},
            {4, 3, 2, 1},
            {7, 8, 9, 6},
            {6, 5, 4, 3}
        };
        printDiagonals(matrix);
    }
}


Python3




def print_diagonals(matrix):
    n = len(matrix)
    # Get the principal diagonal
    principal = [matrix[i][i] for i in range(n)]
    print("Principal Diagonal:", ", ".join(map(str, principal)))
    # Get the secondary diagonal
    secondary = [matrix[i][n-1-i] for i in range(n)]
    print("Secondary Diagonal:", ", ".join(map(str, secondary)))
 
# Example usage
matrix = [[1, 2, 3, 4], [4, 3, 2, 1], [7, 8, 9, 6], [6, 5, 4, 3]]
print_diagonals(matrix)


C#




using System;
 
public class GFG {
    public static void PrintDiagonals(int[,] matrix) {
        int n = matrix.GetLength(0);
         
        // Get the principal diagonal
        int[] principal = new int[n];
        for (int i = 0; i < n; i++) {
            principal[i] = matrix[i, i];
        }
         
        Console.Write("Principal Diagonal: ");
        for (int i = 0; i < n; i++) {
            Console.Write(principal[i]);
            if (i != n - 1) {
                Console.Write(", ");
            }
        }
        Console.WriteLine();
         
        // Get the secondary diagonal
        int[] secondary = new int[n];
        for (int i = 0; i < n; i++) {
            secondary[i] = matrix[i, n - 1 - i];
        }
         
        Console.Write("Secondary Diagonal: ");
        for (int i = 0; i < n; i++) {
            Console.Write(secondary[i]);
            if (i != n - 1) {
                Console.Write(", ");
            }
        }
        Console.WriteLine();
    }
     
    public static void Main(string[] args) {
        int[,] matrix = {
            {1, 2, 3, 4},
            {4, 3, 2, 1},
            {7, 8, 9, 6},
            {6, 5, 4, 3}
        };
         
        PrintDiagonals(matrix);
    }
}


Javascript




function print_diagonals(matrix) {
    let n = matrix.length;
    // Get the principal diagonal
    let principal = [];
    for (let i = 0; i < n; i++) {
        principal.push(matrix[i][i]);
    }
    console.log("Principal Diagonal:", principal.join(", "));
    // Get the secondary diagonal
    let secondary = [];
    for (let i = 0; i < n; i++) {
        secondary.push(matrix[i][n - 1 - i]);
    }
    console.log("Secondary Diagonal:", secondary.join(", "));
}
 
// Example usage
let matrix = [
    [1, 2, 3, 4],
    [4, 3, 2, 1],
    [7, 8, 9, 6],
    [6, 5, 4, 3]
];
print_diagonals(matrix);


Output

Principal Diagonal: 1, 3, 9, 3
Secondary Diagonal: 4, 2, 8, 6





 The time complexity of this approach is also O(n^2)

 The auxiliary space is O(n).



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads