Skip to content
Related Articles

Related Articles

Improve Article

Find smallest and largest element from square matrix diagonals

  • Last Updated : 11 Sep, 2021

Given a square matrix of order n*n, find the smallest and largest elements from both diagonals of the given matrix. 

Examples: 

Input : matrix = {
            {1, 2, 3, 4, -10},
            {5, 6, 7, 8, 6},
            {1, 2, 11, 3, 4},
            {5, 6, 70, 5, 8},
            {4, 9, 7, 1, 5}};
Output :
Principal Diagonal Smallest Element:  1
Principal Diagonal Greatest Element :11
Secondary Diagonal Smallest Element: -10
Secondary Diagonal Greatest Element: 11

The idea behind solving this problem is, First check traverse matrix and reach all diagonals elements (for principle diagonal i == j and secondary diagonal i+j = size_of_matrix-1) and compare diagonal element with min and max variable and take new min and max values. and same thing for secondary diagonals.

Here is implementation of above approach: 

Example 1: With O(n^2) Complexity:  



C++




// CPP program to find smallest and
// largest elements of both diagonals
#include<bits/stdc++.h>
using namespace std;
 
// Function to find smallest and largest element
// from principal and secondary diagonal
void diagonalsMinMax(int mat[5][5])
{
    // take length of matrix
    int n = sizeof(*mat) / 4;
    if (n == 0)
        return;
 
    // declare and initialize variables
    // with appropriate value
    int principalMin = mat[0][0],
        principalMax = mat[0][0];
    int secondaryMin = mat[n - 1][0],
        secondaryMax = mat[n - 1][0];
 
    for (int i = 1; i < n; i++)
    {
        for (int j = 1; j < n; j++)
        {
 
            // Condition for principal
            // diagonal
            if (i == j)
            {
 
                // take new smallest value
                if (mat[i][j] < principalMin)
                {
                    principalMin = mat[i][j];
                }
 
                // take new largest value
                if (mat[i][j] > principalMax)
                {
                    principalMax = mat[i][j];
                }
            }
 
            // Condition for secondary
            // diagonal
            if ((i + j) == (n - 1))
            {
 
                // take new smallest value
                if (mat[i][j] < secondaryMin)
                {
                    secondaryMin = mat[i][j];
                }
 
                // take new largest value
                if (mat[i][j] > secondaryMax)
                {
                    secondaryMax = mat[i][j];
                }
            }
        }
    }
 
    cout << ("Principal Diagonal Smallest Element: ")
        << principalMin << endl;
    cout << ("Principal Diagonal Greatest Element : ")
        << principalMax << endl;
 
    cout << ("Secondary Diagonal Smallest Element: ")
        << secondaryMin << endl;
    cout << ("Secondary Diagonal Greatest Element: ")
        << secondaryMax << endl;
}
 
// Driver code
int main()
{
    // Declare and initialize 5X5 matrix
    int matrix[5][5] = {{ 1, 2, 3, 4, -10 },
                        { 5, 6, 7, 8, 6 },
                        { 1, 2, 11, 3, 4 },
                        { 5, 6, 70, 5, 8 },
                        { 4, 9, 7, 1, -5 }};
    diagonalsMinMax(matrix);
}
 
// This code is contributed by
// Shashank_Sharma

Java




// Java program to find
// smallest and largest elements of both diagonals
 
public class GFG {
    // Function to find smallest and largest element from
    // principal and secondary diagonal
    static void diagonalsMinMax(int[][] mat)
    {
        // take length of matrix
        int n = mat.length;
        if (n == 0)
           return;
 
        // declare and initialize variables with appropriate value
        int principalMin = mat[0][0], principalMax = mat[0][0];
        int secondaryMin = mat[n-1][0], secondaryMax = mat[n-1][0];
 
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
 
                // Condition for principal
                // diagonal
                if (i == j) {
 
                    // take new smallest value
                    if (mat[i][j] < principalMin) {
                        principalMin = mat[i][j];
                    }
 
                    // take new largest value
                    if (mat[i][j] > principalMax) {
                        principalMax = mat[i][j];
                    }
                }
 
                // Condition for secondary
                // diagonal
                if ((i + j) == (n - 1)) {
 
                    // take new smallest value
                    if (mat[i][j] < secondaryMin) {
                        secondaryMin = mat[i][j];
                    }
 
                    // take new largest value
                    if (mat[i][j] > secondaryMax) {
                        secondaryMax = mat[i][j];
                    }
                }
            }
        }
 
        System.out.println("Principal Diagonal Smallest Element:  "
                           + principalMin);
        System.out.println("Principal Diagonal Greatest Element : "
                           + principalMax);
 
        System.out.println("Secondary Diagonal Smallest Element: "
                           + secondaryMin);
        System.out.println("Secondary Diagonal Greatest Element: "
                           + secondaryMax);
    }
 
    // Driver code
    static public void main(String[] args)
    {
 
        // Declare and initialize 5X5 matrix
        int[][] matrix = {
            { 1, 2, 3, 4, -10 },
            { 5, 6, 7, 8, 6 },
            { 1, 2, 11, 3, 4 },
            { 5, 6, 70, 5, 8 },
            { 4, 9, 7, 1, -5 }
        };
 
        diagonalsMinMax(matrix);
    }
}

Python3




# Python3 program to find smallest and
# largest elements of both diagonals
 
# Function to find smallest and largest element
# from principal and secondary diagonal
def diagonalsMinMax(mat):
 
    # take length of matrix
    n = len(mat)
    if (n == 0):
        return
 
    # declare and initialize variables
    # with appropriate value
    principalMin = mat[0][0]
    principalMax = mat[0][0]
    secondaryMin = mat[0][n-1]
    secondaryMax = mat[0][n-1]
 
    for i in range(1, n):
     
        for j in range(1, n):
         
            # Condition for principal
            # diagonal
            if (i == j):
             
                # take new smallest value
                if (mat[i][j] < principalMin):
                 
                    principalMin = mat[i][j]
                 
                # take new largest value
                if (mat[i][j] > principalMax):
                 
                    principalMax = mat[i][j]
                 
            # Condition for secondary
            # diagonal
            if ((i + j) == (n - 1)):
             
                # take new smallest value
                if (mat[i][j] < secondaryMin):
                 
                    secondaryMin = mat[i][j]
                 
                # take new largest value
                if (mat[i][j] > secondaryMax):
                 
                    secondaryMax = mat[i][j]
                 
    print("Principal Diagonal Smallest Element: ",
                                     principalMin)
    print("Principal Diagonal Greatest Element : ",
                                      principalMax)
 
    print("Secondary Diagonal Smallest Element: ",
                                     secondaryMin)
    print("Secondary Diagonal Greatest Element: ",
                                     secondaryMax)
 
# Driver code
 
# Declare and initialize 5X5 matrix
matrix = [[ 1, 2, 3, 4, -10 ],
          [ 5, 6, 7, 8, 6 ],
          [ 1, 2, 11, 3, 4 ],
          [ 5, 6, 70, 5, 8 ],
          [ 4, 9, 7, 1, -5 ]]
diagonalsMinMax(matrix)
 
# This code is contributed by Mohit kumar 29

C#




// C# program to find smallest and largest
//  elements of both diagonals
using System;
 
public class GFG {
    // Function to find smallest and largest element from
    // principal and secondary diagonal
    static void diagonalsMinMax(int[,] mat)
    {
        // take length of square matrix
        int n = mat.GetLength(0);
        if (n == 0)
        return;
 
        // declare and initialize variables with appropriate value
        int principalMin = mat[0,0], principalMax = mat[0,0];
        int secondaryMin = mat[n-1,0], secondaryMax = mat[n-1,0];
 
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < n; j++) {
 
                // Condition for principal
                // diagonal
                if (i == j) {
 
                    // take new smallest value
                    if (mat[i,j] < principalMin) {
                        principalMin = mat[i,j];
                    }
 
                    // take new largest value
                    if (mat[i,j] > principalMax) {
                        principalMax = mat[i,j];
                    }
                }
 
                // Condition for secondary
                // diagonal
                if ((i + j) == (n - 1)) {
 
                    // take new smallest value
                    if (mat[i,j] < secondaryMin) {
                        secondaryMin = mat[i,j];
                    }
 
                    // take new largest value
                    if (mat[i,j] > secondaryMax) {
                        secondaryMax = mat[i,j];
                    }
                }
            }
        }
 
        Console.WriteLine("Principal Diagonal Smallest Element: "
                        + principalMin);
        Console.WriteLine("Principal Diagonal Greatest Element : "
                        + principalMax);
 
        Console.WriteLine("Secondary Diagonal Smallest Element: "
                        + secondaryMin);
        Console.WriteLine("Secondary Diagonal Greatest Element: "
                        + secondaryMax);
    }
 
    // Driver code
    static void Main()
    {
 
        // Declare and initialize 5X5 matrix
        int[,] matrix = {
            { 1, 2, 3, 4, -10 },
            { 5, 6, 7, 8, 6 },
            { 1, 2, 11, 3, 4 },
            { 5, 6, 70, 5, 8 },
            { 4, 9, 7, 1, -5 }
        };
 
        diagonalsMinMax(matrix);
    }
    // This code is contributed by Ryuga
}

PHP




<?php
// PHP program to find smallest and
// largest elements of both diagonals
 
// Function to find smallest and largest element
// from principal and secondary diagonal
function diagonalsMinMax($mat)
{
    // take length of $matrix
    $n = count($mat);
    if ($n == 0)
        return;
 
    // declare and initialize variables
    // with appropriate value
    $principalMin = $mat[0][0];
    $principalMax = $mat[0][0];
    $secondaryMin = $mat[$n - 1][0];
    $secondaryMax = $mat[$n - 1][0];
 
    for ($i = 1; $i < $n; $i++)
    {
        for ($j = 1; $j < $n; $j++)
        {
 
            // Condition for principal
            // diagonal
            if ($i == $j)
            {
 
                // take new smallest value
                if ($mat[$i][$j] < $principalMin)
                {
                    $principalMin = $mat[$i][$j];
                }
 
                // take new largest value
                if ($mat[$i][$j] > $principalMax)
                {
                    $principalMax = $mat[$i][$j];
                }
            }
 
            // Condition for secondary
            // diagonal
            if (($i + $j) == ($n - 1))
            {
 
                // take new smallest value
                if ($mat[$i][$j] < $secondaryMin)
                {
                    $secondaryMin = $mat[$i][$j];
                }
 
                // take new largest value
                if ($mat[$i][$j] > $secondaryMax)
                {
                    $secondaryMax = $mat[$i][$j];
                }
            }
        }
    }
 
    echo "Principal Diagonal Smallest Element: ",
                             $principalMin, "\n";
    echo "Principal Diagonal Greatest Element : ",
                              $principalMax, "\n";
 
    echo "Secondary Diagonal Smallest Element: ",
                             $secondaryMin, "\n";
    echo "Secondary Diagonal Greatest Element: ",
                             $secondaryMax, "\n";
}
 
// Driver code
 
// Declare and initialize 5X5 matrix
$matrix = array(array ( 1, 2, 3, 4, -10 ),
                array ( 5, 6, 7, 8, 6 ),
                array ( 1, 2, 11, 3, 4 ),
                array ( 5, 6, 70, 5, 8 ),
                array ( 4, 9, 7, 1, -5 ));
diagonalsMinMax($matrix);
 
// This code is contributed by
// ihritik
?>

Javascript




<script>
// Javascript program to find smallest and
// largest elements of both diagonals
 
// Function to find smallest and largest element
// from principal and secondary diagonal
function diagonalsMinMax(mat)
{
    // take length of matrix
    let n = mat.length;
    if (n == 0)
        return;
 
    // declare and initialize variables
    // with appropriate value
    let principalMin = mat[0][0],
        principalMax = mat[0][0];
    let secondaryMin = mat[n - 1][0],
        secondaryMax = mat[n - 1][0];
 
    for (let i = 1; i < n; i++)
    {
        for (let j = 1; j < n; j++)
        {
 
            // Condition for principal
            // diagonal
            if (i == j)
            {
 
                // take new smallest value
                if (mat[i][j] < principalMin)
                {
                    principalMin = mat[i][j];
                }
 
                // take new largest value
                if (mat[i][j] > principalMax)
                {
                    principalMax = mat[i][j];
                }
            }
 
            // Condition for secondary
            // diagonal
            if ((i + j) == (n - 1))
            {
 
                // take new smallest value
                if (mat[i][j] < secondaryMin)
                {
                    secondaryMin = mat[i][j];
                }
 
                // take new largest value
                if (mat[i][j] > secondaryMax)
                {
                    secondaryMax = mat[i][j];
                }
            }
        }
    }
 
    document.write("Principal Diagonal Smallest Element: "
        + principalMin + "<br>");
    document.write("Principal Diagonal Greatest Element : "
        + principalMax + "<br>");
 
    document.write("Secondary Diagonal Smallest Element: "
        + secondaryMin + "<br>");
    document.write("Secondary Diagonal Greatest Element: "
        + secondaryMax + "<br>");
}
 
// Driver code
    // Declare and initialize 5X5 matrix
    let matrix = [[ 1, 2, 3, 4, -10 ],
                        [ 5, 6, 7, 8, 6 ],
                        [ 1, 2, 11, 3, 4 ],
                        [ 5, 6, 70, 5, 8 ],
                        [ 4, 9, 7, 1, -5 ]];
    diagonalsMinMax(matrix);
 
// This code is contributed by subham348.
</script>
Output: 
Principal Diagonal Smallest Element:  -5
Principal Diagonal Greatest Element : 11
Secondary Diagonal Smallest Element: 4
Secondary Diagonal Greatest Element: 11

 

Example 2: With O(n) Complexity: 

C++




// C++ program to find
// smallest and largest elements of both diagonals
#include<bits/stdc++.h>
using namespace std;
 
const int n = 5;
 
// Function to find smallest and largest element
// from principal and secondary diagonal
void diagonalsMinMax(int mat [n][n])
{
    // take length of matrix
    if (n == 0)
        return;
 
    // declare and initialize variables
    // with appropriate value
    int principalMin = mat[0][0],
        principalMax = mat[0][0];
    int secondaryMin = mat[n - 1][0],
        secondaryMax = mat[n - 1][0];
 
    for (int i = 0; i < n; i++)
    {
 
        // Condition for principal
        // diagonal mat[i][i]
 
        // take new smallest value
        if (mat[i][i] < principalMin)
        {
            principalMin = mat[i][i];
        }
         
        // take new largest value
        if (mat[i][i] > principalMax)
        {
            principalMax = mat[i][i];
        }
 
        // Condition for secondary
        // diagonal is mat[n-1-i][i]
        // take new smallest value
        if (mat[n - 1 - i][i] < secondaryMin)
        {
            secondaryMin = mat[n - 1 - i][i];
        }
         
        // take new largest value
        if (mat[n - 1 - i][i] > secondaryMax)
        {
            secondaryMax = mat[n - 1 - i][i];
        }
    }
    cout << "Principal Diagonal Smallest Element: "
         << principalMin << "\n";
    cout << "Principal Diagonal Greatest Element : "
         << principalMax << "\n";
 
    cout << "Secondary Diagonal Smallest Element: "
         << secondaryMin << "\n";
    cout << "Secondary Diagonal Greatest Element: "
         << secondaryMax;
}
 
// Driver code
int main()
{
 
    // Declare and initialize 5X5 matrix
    int matrix [n][n] = {{ 1, 2, 3, 4, -10 },
                         { 5, 6, 7, 8, 6 },
                         { 1, 2, 11, 3, 4 },
                         { 5, 6, 70, 5, 8 },
                         { 4, 9, 7, 1, -5 }};
 
    diagonalsMinMax(matrix);
}
 
// This code is contributed by ihritik

Java




// Java program to find
// smallest and largest elements of both diagonals
 
public class GFG {
 
    // Function to find smallest and largest element from
    // principal and secondary diagonal
    static void diagonalsMinMax(int[][] mat)
    {
        // take length of matrix
        int n = mat.length;
        if (n == 0)
           return;
 
        // declare and initialism variables with appropriate value
        int principalMin = mat[0][0], principalMax = mat[0][0];
        int secondaryMin = mat[n-1][0], secondaryMax = mat[n-1][0];
 
        for (int i = 0; i < n; i++) {
 
            // Condition for principal
            // diagonal mat[i][i]
 
            // take new smallest value
            if (mat[i][i] < principalMin) {
                principalMin = mat[i][i];
            }
            // take new largest value
            if (mat[i][i] > principalMax) {
                principalMax = mat[i][i];
            }
 
            // Condition for secondary
            // diagonal is mat[n-1-i][i]
            // take new smallest value
            if (mat[n - 1 - i][i] < secondaryMin) {
                secondaryMin = mat[n - 1 - i][i];
            }
            // take new largest value
            if (mat[n - 1 - i][i] > secondaryMax) {
                secondaryMax = mat[n - 1 - i][i];
            }
        }
        System.out.println("Principal Diagonal Smallest Element:  "
                           + principalMin);
        System.out.println("Principal Diagonal Greatest Element : "
                           + principalMax);
 
        System.out.println("Secondary Diagonal Smallest Element: "
                           + secondaryMin);
        System.out.println("Secondary Diagonal Greatest Element: "
                           + secondaryMax);
    }
 
    // Driver code
    static public void main(String[] args)
    {
 
        // Declare and initialize 5X5 matrix
        int[][] matrix = {
            { 1, 2, 3, 4, -10 },
            { 5, 6, 7, 8, 6 },
            { 1, 2, 11, 3, 4 },
            { 5, 6, 70, 5, 8 },
            { 4, 9, 7, 1, -5 }
        };
 
        diagonalsMinMax(matrix);
    }
}

Python




# Python3 program to find smallest and
# largest elements of both diagonals
 
n = 5
 
# Function to find smallest and largest element
# from principal and secondary diagonal
def diagonalsMinMax(mat):
     
    # take length of matrix
    if (n == 0):
        return
 
    # declare and initialize variables
    # with appropriate value
    principalMin = mat[0][0]
    principalMax = mat[0][0]
    secondaryMin = mat[n - 1][0]
    secondaryMax = mat[n - 1][0]
 
    for i in range(n):
 
        # Condition for principal
        # diagonal mat[i][i]
 
        # take new smallest value
        if (mat[i][i] < principalMin):
            principalMin = mat[i][i]
 
        # take new largest value
        if (mat[i][i] > principalMax):
            principalMax = mat[i][i]
 
        # Condition for secondary
        # diagonal is mat[n-1-i][i]
        # take new smallest value
        if (mat[n - 1 - i][i] < secondaryMin):
            secondaryMin = mat[n - 1 - i][i]
 
        # take new largest value
        if (mat[n - 1 - i][i] > secondaryMax):
            secondaryMax = mat[n - 1 - i][i]
 
    print("Principal Diagonal Smallest Element: ",principalMin)
    print("Principal Diagonal Greatest Element : ",principalMax)
 
    print("Secondary Diagonal Smallest Element: ",secondaryMin)
    print("Secondary Diagonal Greatest Element: ",secondaryMax)
 
# Driver code
 
# Declare and initialize 5X5 matrix
matrix= [[ 1, 2, 3, 4, -10 ],
        [ 5, 6, 7, 8, 6 ],
        [ 1, 2, 11, 3, 4 ],
        [ 5, 6, 70, 5, 8 ],
        [ 4, 9, 7, 1, -5 ]]
 
diagonalsMinMax(matrix)
 
# This code is contributed by mohit kumar 29

C#




// C# program to find smallest and largest
// elements of both diagonals
using System;
 
public class GFG {
    // Function to find smallest and largest element from
    // principal and secondary diagonal
    static void diagonalsMinMax(int[,] mat)
    {
        // take length of square matrix
        int n = mat.GetLength(0);
        if (n == 0)
        return;
 
        // declare and initialize variables with appropriate value
        int principalMin = mat[0,0], principalMax = mat[0,0];
        int secondaryMin = mat[n-1,0], secondaryMax = mat[n-1,0];
 
        for (int i = 0; i < n; i++) {
   
            // Condition for principal
            // diagonal mat[i][i]
   
            // take new smallest value
            if (mat[i,i] < principalMin) {
                principalMin = mat[i,i];
            }
            // take new largest value
            if (mat[i,i] > principalMax) {
                principalMax = mat[i,i];
            }
   
            // Condition for secondary
            // diagonal is mat[n-1-i][i]
            // take new smallest value
            if (mat[n - 1 - i,i] < secondaryMin) {
                secondaryMin = mat[n - 1 - i,i];
            }
            // take new largest value
            if (mat[n - 1 - i,i] > secondaryMax) {
                secondaryMax = mat[n - 1 - i,i];
            }
         
        }
 
        Console.WriteLine("Principal Diagonal Smallest Element: "
                        + principalMin);
        Console.WriteLine("Principal Diagonal Greatest Element : "
                        + principalMax);
 
        Console.WriteLine("Secondary Diagonal Smallest Element: "
                        + secondaryMin);
        Console.WriteLine("Secondary Diagonal Greatest Element: "
                        + secondaryMax);
    }
 
    // Driver code
    public static void Main()
    {
 
        // Declare and initialize 5X5 matrix
        int[,] matrix = {
            { 1, 2, 3, 4, -10 },
            { 5, 6, 7, 8, 6 },
            { 1, 2, 11, 3, 4 },
            { 5, 6, 70, 5, 8 },
            { 4, 9, 7, 1, -5 }
        };
 
        diagonalsMinMax(matrix);
    }
}
 
/*This code is contributed by 29AjayKumar*/

Javascript




<script>
 
// JavaScript program to find
// smallest and largest elements
// of both diagonals
 
    // Function to find smallest
    // and largest element from
    // principal and secondary diagonal
    function diagonalsMinMax(mat)
    {
        // take length of matrix
        let n = mat.length;
        if (n == 0)
        return;
 
        // declare and initialism variables
        // with appropriate value
        let principalMin = mat[0][0],
            principalMax = mat[0][0];
        let secondaryMin = mat[n-1][0],
            secondaryMax = mat[n-1][0];
 
        for (let i = 0; i < n; i++) {
 
            // Condition for principal
            // diagonal mat[i][i]
 
            // take new smallest value
            if (mat[i][i] < principalMin) {
                principalMin = mat[i][i];
            }
            // take new largest value
            if (mat[i][i] > principalMax) {
                principalMax = mat[i][i];
            }
 
            // Condition for secondary
            // diagonal is mat[n-1-i][i]
            // take new smallest value
            if (mat[n - 1 - i][i] < secondaryMin) {
                secondaryMin = mat[n - 1 - i][i];
            }
            // take new largest value
            if (mat[n - 1 - i][i] > secondaryMax) {
                secondaryMax = mat[n - 1 - i][i];
            }
        }
        document.write("Principal Diagonal Smallest Element: "
                        + principalMin+"<br>");
        document.write("Principal Diagonal Greatest Element : "
                        + principalMax+"<br>");
 
        document.write("Secondary Diagonal Smallest Element: "
                        + secondaryMin+"<br>");
        document.write("Secondary Diagonal Greatest Element: "
                        + secondaryMax+"<br>");
    }
 
    // Driver code
     
 
        // Declare and initialize 5X5 matrix
        let matrix = [
            [ 1, 2, 3, 4, -10 ],
            [ 5, 6, 7, 8, 6 ],
            [ 1, 2, 11, 3, 4 ],
            [ 5, 6, 70, 5, 8 ],
            [ 4, 9, 7, 1, -5 ]
        ];
 
        diagonalsMinMax(matrix);
 
 
// This code is contributed by sravan kumar
 
</script>
Output: 
Principal Diagonal Smallest Element:  -5
Principal Diagonal Greatest Element : 11
Secondary Diagonal Smallest Element: -10
Secondary Diagonal Greatest Element: 11

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :