Program to print the Diagonals of a Matrix
Last Updated :
09 Oct, 2023
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++
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
void printPrincipalDiagonal(int mat[][MAX], int n)
{
cout << "Principal Diagonal: ";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j)
cout << mat[i][j] << ", ";
}
}
cout << endl;
}
void printSecondaryDiagonal(int mat[][MAX], int n)
{
cout << "Secondary Diagonal: ";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i + j) == (n - 1))
cout << mat[i][j] << ", ";
}
}
cout << endl;
}
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
class GFG {
static int MAX = 100;
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++) {
if (i == j) {
System.out.print(mat[i][j] + ", ");
}
}
}
System.out.println("");
}
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++) {
if ((i + j) == (n - 1)) {
System.out.print(mat[i][j] + ", ");
}
}
}
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);
}
}
|
Python3
MAX = 100
def printPrincipalDiagonal(mat, n):
print("Principal Diagonal: ", end = "")
for i in range(n):
for j in range(n):
if (i == j):
print(mat[i][j], end = ", ")
print()
def printSecondaryDiagonal(mat, n):
print("Secondary Diagonal: ", end = "")
for i in range(n):
for j in range(n):
if ((i + j) == (n - 1)):
print(mat[i][j], end = ", ")
print()
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)
|
C#
using System;
class GFG {
static int MAX = 100;
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++) {
if (i == j) {
Console.Write(mat[i, j] + ", ");
}
}
}
Console.WriteLine("");
}
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++) {
if ((i + j) == (n - 1)) {
Console.Write(mat[i, j] + ", ");
}
}
}
Console.WriteLine("");
}
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);
}
}
|
Javascript
<script>
let MAX = 100;
function printPrincipalDiagonal(mat, n)
{
document.write("Principal Diagonal: ");
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
if (i == j) {
document.write(mat[i][j] + ", ");
}
}
}
document.write("</br>");
}
function printSecondaryDiagonal(mat, n)
{
document.write("Secondary Diagonal: ");
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
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:
- 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.
- 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++
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100;
void printPrincipalDiagonal(int mat[][MAX], int n)
{
cout << "Principal Diagonal: ";
for (int i = 0; i < n; i++) {
cout << mat[i][i] << ", ";
}
cout << endl;
}
void printSecondaryDiagonal(int mat[][MAX], int n)
{
cout << "Secondary Diagonal: ";
int k = n - 1;
for (int i = 0; i < n; i++) {
cout << mat[i][k--] << ", ";
}
cout << endl;
}
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
class Main{
static int MAX = 100;
public static void printPrincipalDiagonal(int mat[][],
int n)
{
System.out.print("Principal Diagonal: ");
for (int i = 0; i < n; i++)
{
System.out.print(mat[i][i] + ", ");
}
System.out.println();
}
public static void printSecondaryDiagonal(int mat[][],
int n)
{
System.out.print("Secondary Diagonal: ");
int k = n - 1;
for (int i = 0; i < n; i++)
{
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);
}
}
|
Python3
MAX = 100
def printPrincipalDiagonal(mat, n):
print("Principal Diagonal: ", end = "")
for i in range(n):
print(mat[i][i], end = ", ")
print()
def printSecondaryDiagonal(mat, n):
print("Secondary Diagonal: ", end = "")
k = n - 1
for i in range(n):
print(mat[i][k], end = ", ")
k -= 1
print()
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)
|
C#
using System;
class GFG{
static void printPrincipalDiagonal(int [,]mat,
int n)
{
Console.Write("Principal Diagonal: ");
for (int i = 0; i < n; i++)
{
Console.Write(mat[i, i] + ", ");
}
Console.Write("\n");
}
static void printSecondaryDiagonal(int [,]mat,
int n)
{
Console.Write("Secondary Diagonal: ");
int k = n - 1;
for (int i = 0; i < n; i++)
{
Console.Write(mat[i, k--] + ", ");
}
Console.Write("\n");
}
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);
}
}
|
Javascript
<script>
let MAX = 100;
function printPrincipalDiagonal(mat, n)
{
document.write("Principal Diagonal: ");
for (let i = 0; i < n; i++)
{
document.write(mat[i][i] + ", ");
}
document.write("</br>");
}
function printSecondaryDiagonal(mat, n)
{
document.write("Secondary Diagonal: ");
let k = n - 1;
for (let i = 0; i < n; i++)
{
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>
void printDiagonals(std::vector<std::vector<int> >& matrix)
{
int n
= matrix
.size();
std::vector<int> principal(n);
for (int i = 0; i < n; i++) {
principal[i] = matrix[i][i];
}
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;
std::vector<int> secondary(n);
for (int i = 0; i < n; i++) {
secondary[i] = matrix[i][n - 1 - i];
}
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;
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();
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)
principal = [matrix[i][i] for i in range(n)]
print("Principal Diagonal:", ", ".join(map(str, principal)))
secondary = [matrix[i][n-1-i] for i in range(n)]
print("Secondary Diagonal:", ", ".join(map(str, secondary)))
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);
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();
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;
let principal = [];
for (let i = 0; i < n; i++) {
principal.push(matrix[i][i]);
}
console.log("Principal Diagonal:", principal.join(", "));
let secondary = [];
for (let i = 0; i < n; i++) {
secondary.push(matrix[i][n - 1 - i]);
}
console.log("Secondary Diagonal:", secondary.join(", "));
}
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
Share your thoughts in the comments
Please Login to comment...