How to access elements of a Square Matrix

A square matrix is a matrix which includes elements in the form of Rows and Columns. Below is an example of a 5×5 matrix. 

A 5×5 Square Matrix

A Matrix is accessed by: Matrix_Name[row_index][column_index]

Below are the various ways to access a Square Matrix in different forms: 

• Elements on the main diagonal

Approach:

row_index == column_index

Implementation:

C++

// C++ Program to read a square matrix
// and print the main diagonal elements
#include <iostream>
using namespace std;

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout << "The matrix is" << endl;
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout << matrix[row_index][column_index] << " ";
        }

        cout << endl;
    }

    // Print the main diagonal elements
    cout << "\nMain diagonal elements are:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for main diagonal elements
            if (row_index == column_index)
                cout << matrix[row_index][column_index] << ", ";
        }
    }

    return 0;
}

// This code is contributed by SHUBHAMSINGH10

C

// C Program to read a square matrix
// and print the main diagonal elements

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the main diagonal elements
    printf("\nMain diagonal elements are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for main diagonal elements
            if (row_index == column_index)
                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

// Java Program to read a square matrix
// and print the main diagonal elements
class GFG
{

    public static void main(String[] args)
    {

        int matrix[][] = new int[5][5], row_index,
                    column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                System.out.printf("%d\t", matrix[row_index][column_index]);
            }

            System.out.printf("\n");
        }

        // Print the main diagonal elements
        System.out.printf("\nMain diagonal elements are:\n");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                // check for main diagonal elements
                if (row_index == column_index)
                {
                    System.out.printf("%d, ", matrix[row_index][column_index]);
                }
            }
        }

    }
}

// This code is contributed by 29AjayKumar

Python3

# Python Program to read a square matrix
# and print the main diagonal elements

if __name__ == '__main__':

    matrix = [[0 for i in range(5)] for j in range(5)]
    x, size = 0, 5;

    # Get the square matrix
    for row_index in range(size):
        for column_index in range(size):
            x += 1;
            matrix[row_index][column_index] = x;

    # Display the matrix
    print("The matrix is");
    for row_index in range(size):
        for column_index in range(size):
            print( matrix[row_index][column_index],end = "\t");

        print("");

    # Print the main diagonal elements
    print("\nMain diagonal elements are:");

    for row_index in range(size):
        for column_index in range(size):

            # check for main diagonal elements
            if (row_index == column_index):
                print(matrix[row_index][column_index], end="\t");

# This code is contributed by 29AjayKumar

C#

//C# Program to read a square matrix
// and print the main diagonal elements
using System;
public class GFG{


    public static void Main() {

        int [,]matrix = new int[5,5];
        int row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index,column_index] = ++x;
            }
        }

        // Display the matrix
        Console.WriteLine("The matrix is");
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                Console.Write(matrix[row_index,column_index]+"\t");
            }

            Console.WriteLine();
        }

        // Print the main diagonal elements
        Console.Write("\nMain diagonal elements are:\n");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for main diagonal elements
                if (row_index == column_index) {
                    Console.Write(matrix[row_index,column_index]+",");
                }
            }
        }

    }
}


// This code is contributed by 29AjayKumar

Javascript

<script>
// Javascript Program to read a square matrix
// and print the main diagonal elements

    let matrix = new Array(5), row_index,
                    column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++)
        {
            matrix[row_index]=new Array(5);
            for (column_index = 0; column_index < size;
                 column_index++)
            {

                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        document.write("The matrix is<br>");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                document.write( matrix[row_index][column_index]+
                               "   ");
            }

            document.write("<br>");
        }

        // Print the main diagonal elements
        document.write("<br>Main diagonal elements are:<br>");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                // check for main diagonal elements
                if (row_index == column_index)
                {
                    document.write( matrix[row_index][column_index]
                                   +", ");
                }
            }
        }


// This code is contributed by rag2127
</script>

Output

The matrix is
1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20 
21 22 23 24 25 

Main diagonal elements are:
1, 7, 13, 19, 25, 

Complexity Analysis:

• Time Complexity: O(size * size)
• Auxiliary Space: O(size * size)
• Elements above the main diagonal:

Approach:

row_index < column_index

Implementation:

C++

// C++ Program to read a square matrix
// and print the elements above main diagonal

#include <iostream>
using namespace std;

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout  << "The matrix is\n";
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout << matrix[row_index][column_index] << " ";
        }

        cout << endl;
    }

    // Print the elements above main diagonal
    cout<<"\nElements above Main diagonal elements are:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements above main diagonal
            if (row_index < column_index)
            cout << matrix[row_index][column_index] << ", ";

        }
    }

    return 0;
}

//This code is contributed by shubhamsingh10

C

// C Program to read a square matrix
// and print the elements above the main diagonal

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the elements above main diagonal
    printf("\nElements above Main diagonal elements are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements above main diagonal
            if (row_index < column_index)
                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

// Java Program to read a square matrix
// and print the elements above the main diagonal

class GFG {

    public static void main(String args[]) {
        int matrix[][] = new int[5][5], row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                System.out.printf("%d\t", matrix[row_index][column_index]);
            }

            System.out.printf("\n");
        }

        // Print the elements above the main diagonal
        System.out.printf("\nElements above Main diagonal elements are:\n");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for elements above main diagonal
                if (row_index < column_index) {
                    System.out.printf("%d, ", matrix[row_index][column_index]);
                }
            }
        }
    }

}
// This code is contributed by PrinciRaj19992

Python3

# Python3 Program to read a square matrix
# and print the elements above main diagonal
if __name__ == '__main__':
    matrix = [[0 for i in range(5)] for j in range(5)];
    row_index, column_index, x, size = 0, 0, 0, 5;

    # Get the square matrix
    for row_index in range(size):
        for column_index in range(size):
            x += 1;
            matrix[row_index][column_index] = x;

    # Display the matrix
    print("The matrix is");
    for row_index in range(size):
        for column_index in range(size):
            print( matrix[row_index][column_index], end = "\t");

        print("");

    # Print the elements above main diagonal
    print("\nElements above Main diagonal elements are:");

    for row_index in range(size):
        for column_index in range(size):

            # check for elements above main diagonal
            if (row_index < column_index):
                print(matrix[row_index][column_index], end=" ");

# This code is contributed by 29AjayKumar

C#

// C# Program to read a square matrix
// and print the elements above main diagonal
 using System;
public class GFG {

    public static void Main() {
        int [,] matrix= new int[5,5];
        int row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index,column_index] = ++x;
            }
        }

        // Display the matrix
        Console.Write("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                Console.Write(matrix[row_index,column_index]+"\t");
            }

            Console.Write("\n");
        }

        // Print the elements above the main diagonal
        Console.Write("\nElements above Main diagonal elements are:\n");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for elements above main diagonal
                if (row_index < column_index) {
                    Console.Write(matrix[row_index,column_index]+", ");
                }
            }
        }
    }

}
// This code is contributed by PrinciRaj19992

Javascript

<script>

// JavaScript Program to read a square matrix
// and print the elements above the main diagonal

    let matrix = new Array(5), row_index, column_index,
    x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++)
        {
            matrix[row_index]=new Array(5);
            for (column_index = 0; column_index < size;
            column_index++)
            {

                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        document.write("The matrix is<br>");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size;
            column_index++)
            {

                document.write( matrix[row_index]
                [column_index]+"   ");
            }

            document.write("<br>");
        }

        // Print the elements above the main diagonal
        document.write(
        "<br>Elements above Main diagonal elements are:<br>"
        );

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size;
            column_index++)
            {

                // check for elements above main diagonal
                if (row_index < column_index) {
                    document.write( matrix[row_index]
                    [column_index]+ ", ");
                }
            }
        }


// This code is contributed by avanitrachhadiya2155

</script>

Output

The matrix is
1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20 
21 22 23 24 25 

Elements above Main diagonal elements are:
2, 3, 4, 5, 8, 9, 10, 14, 15, 20, 

•  Elements below the main diagonal:
  

Approach:

row_index > column_index

Implementation:

C++

// C++ Program to read a square matrix
// and print the elements below main diagonal

#include <iostream>
using namespace std;

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout << "The matrix is\n";
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout << matrix[row_index][column_index] <<"  ";
        }

        cout << endl;
    }

    // Print the elements below main diagonal
    cout << "\nElements below Main diagonal elements are:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements below main diagonal
            if (row_index > column_index)
                cout << matrix[row_index][column_index]<< ", ";
        }
    }

    return 0;
}

//This code is contributed by shubhamsingh10

C

// C Program to read a square matrix
// and print the elements below the main diagonal

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the elements below main diagonal
    printf("\nElements below Main diagonal elements are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements below main diagonal
            if (row_index > column_index)
                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

class GFG {

// Java Program to read a square matrix
// and print the elements below the main diagonal
    public static void main(String[] args) {

        int matrix[][] = new int[5][5], row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                System.out.printf("%d\t", matrix[row_index][column_index]);
            }

            System.out.printf("\n");
        }

        // Print the elements below main diagonal
        System.out.printf("\nElements below Main diagonal elements are:\n");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for elements below main diagonal
                if (row_index > column_index) {
                    System.out.printf("%d, ", matrix[row_index][column_index]);
                }
            }
        }
    }

}
// This code is contributed by PrinciRaj1992

Python3

# python Program to read a square matrix
# and print the elements below main diagonal


if __name__ == "__main__":

    matrix = [[0 for x in range(5)]for y in range(5)]
    x = 0
    size = 5

    # Get the square matrix
    for row_index in range(0, size):
        for column_index in range(0, size):
            x += 1
            matrix[row_index][column_index] = x

    # Display the matrix
    print("The matrix is")
    for row_index in range(0, size):
        for column_index in range(0, size):

            print(matrix[row_index][column_index], end="  ")

        print()
    # Print the elements below main diagonal
    print()
    print("Elements below Main diagonal elements are:")

    for row_index in range(0, size):
        for column_index in range(0, size):

            # check for elements below main diagonal
            if (row_index > column_index):
                print(matrix[row_index][column_index], end=", ")

C#

// C# program of above approach
using System;
public class GFG {

// Java Program to read a square matrix
// and print the elements below main diagonal
    public static void Main() {

        int [,]matrix = new int[5,5]; int row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index,column_index] = ++x;
            }
        }

        // Display the matrix
        Console.Write("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                Console.Write("{0}\t", matrix[row_index,column_index]);
            }

            Console.Write("\n");
        }

        // Print the elements below main diagonal
        Console.Write("\nElements below Main diagonal elements are:\n");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for elements below main diagonal
                if (row_index > column_index) {
                    Console.Write("{0}, ", matrix[row_index,column_index]);
                }
            }
        }
    }

}
// This code is contributed by Rajput-Ji

Javascript

<script>
// Javascript Program to read a square matrix
// and print the elements below the main diagonal

    let matrix = new Array(5);
    for(let i = 0; i < 5; i++)
    {
        matrix[i] = new Array(5);
        for(let j = 0; j < 5; j++)
        {
            matrix[i][j] = 0;
        }
    }

    let row_index, column_index, x = 0, size = 5;
    // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index][column_index] = ++x;
            }
        }

    // Display the matrix
    document.write("The matrix is<br>");
    for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                document.write( matrix[row_index][column_index]+"   ");
            }

            document.write("<br>");
        }

        // Print the elements below main diagonal
        document.write("<br>Elements below Main diagonal elements are:<br>");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for elements below main diagonal
                if (row_index > column_index) {
                    document.write( matrix[row_index][column_index]+", ");
                }
            }
        }

// This code is contributed by patel2127
</script>

Output

The matrix is
1  2  3  4  5  
6  7  8  9  10  
11  12  13  14  15  
16  17  18  19  20  
21  22  23  24  25  

Elements below Main diagonal elements are:
6, 11, 12, 16, 17, 18, 21, 22, 23, 24, 

• Elements on the secondary diagonal:

Approach:

(row_index + column_index) == size-1

Implementation:

C++

// C++ Program to read a square matrix
// and print the elements on secondary diagonal

#include <bits/stdc++.h>
using namespace std;

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout << "The matrix is\n";
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout <<  matrix[row_index][column_index] << " ";
        }

        cout << endl;
    }

    // Print the elements on secondary diagonal
    cout << "\nElements on Secondary diagonal:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements on secondary diagonal
            if ((row_index + column_index) == size - 1)
                cout << matrix[row_index][column_index]<< ", ";
        }
    }

    return 0;
}

//This code is contributed by shubhamsingh10

C

// C Program to read a square matrix
// and print the elements on secondary diagonal

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the elements on secondary diagonal
    printf("\nElements on Secondary diagonal:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements on secondary    diagonal
            if ((row_index + column_index) == size - 1)
                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

// Java  Program to read a square matrix
// and print the elements on secondary diagonal

import java.io.*;

class GFG {
    public static void main (String[] args) {

    int matrix[][]=new int[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
        System.out.printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

                System.out.printf("%d\t", matrix[row_index][column_index]);
        }

        System.out.printf("\n");
    }

    // Print the elements on secondary diagonal
        System.out.printf("\nElements on Secondary diagonal:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements on secondary diagonal
            if ((row_index + column_index) == size - 1)
                    System.out.printf("%d, ", matrix[row_index][column_index]);
        }
    }
    }
}
//This code is contributed by ajit.

C#

// C# Program to read a square matrix
// and print the elements on secondary diagonal
using System;

class GFG
{
public static void Main (String[] args)
{
    int [,]matrix = new int[5, 5];
    int row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size; column_index++)
        {
            matrix[row_index, column_index] = ++x;
        }
    }

    // Display the matrix
    Console.Write("The matrix is\n");

    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size; column_index++)
        {
            Console.Write("{0}\t", matrix[row_index,
                                          column_index]);
        }
        Console.Write("\n");
    }

    // Print the elements on secondary diagonal
    Console.Write("\nElements on Secondary diagonal:\n");

    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size; column_index++)
        {

            // check for elements on secondary diagonal
            if ((row_index + column_index) == size - 1)
                    Console.Write("{0}, ", matrix[row_index,
                                                  column_index]);
        }
    }
    }
}

// This code is contributed by 29AjayKumar

Javascript

<script>

// Javascript  Program to read a square matrix
// and print the elements on secondary diagonal
let matrix = new Array(5);
for(let i = 0; i < 5; i++)
{
    matrix[i] = new Array(5);
    for(let j = 0; j < 5; j++)
    {
        matrix[i][j] = 0;
    }
}

let row_index, column_index, x = 0, size = 5;

// Get the square matrix
for(row_index = 0;
    row_index < size;
    row_index++)
{
    for(column_index = 0;
        column_index < size;
        column_index++)
    {

        matrix[row_index][column_index] = ++x;
    }
}

// Display the matrix
document.write("The matrix is<br>");
for(row_index = 0;
    row_index < size;
    row_index++)
{
    for(column_index = 0;
        column_index < size;
        column_index++)
    {
        document.write(matrix[row_index][column_index] +
                      "  ");
    }
    document.write("<br>");
}

// Print the elements on secondary diagonal
document.write("<br>Elements on Secondary diagonal:<br>");

for(row_index = 0; row_index < size; row_index++)
{
    for(column_index = 0;
        column_index < size;
        column_index++)
    {

        // Check for elements on secondary diagonal
        if ((row_index + column_index) == size - 1)
                document.write(
                    matrix[row_index][column_index] + ", ");
    }
}

// This code is contributed by unknown2108

</script>

Python3

# Python3  Program to read a square matrix
# and print the elements on secondary diagonal
matrix = []

for i in range(5):
    matrix.append([0 for _ in range(5)])

x = 0
size = 5

# Get the square matrix
for row_index in range(size):

    for column_index in range(size):
        x += 1
        matrix[row_index][column_index] = x


# Display the matrix
print("The matrix is")
for row_index in range(size):
    print(*matrix[row_index])


# Print the elements on secondary diagonal
print("\nElements on Secondary diagonal:")

for row_index in range(size):
    for column_index in range(size):

        # Check for elements on secondary diagonal
        if ((row_index + column_index) == size - 1):
            print(matrix[row_index][column_index], end=", ", sep="")


# This code is contributed by unknown2108

Output

The matrix is
1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20 
21 22 23 24 25 

Elements on Secondary diagonal:
5, 9, 13, 17, 21, 

• Address of elements above the secondary diagonal : 

Approach:

(row_index + column_index) < size-1

Implementation:

C++

// C++ Program to read a square matrix
// and print the elements above secondary diagonal

#include <bits/stdc++.h>
using namespace std;

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout << "The matrix is\n";
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout << matrix[row_index][column_index] << " ";
        }

        cout << endl;
    }

    // Print the elements above secondary diagonal
    cout << "\nElements above Secondary diagonal are:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements above secondary diagonal
            if ((row_index + column_index) < size - 1)
                cout << matrix[row_index][column_index]<< ", ";
        }
    }

    return 0;
}

// This code is contributed by shivanisinghss2110

C

// C Program to read a square matrix
// and print the elements above secondary diagonal

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the elements above secondary diagonal
    printf("\nElements above Secondary diagonal are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements above secondary diagonal
            if ((row_index + column_index) < size - 1)
                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

// Java Program to read a square matrix
// and print the elements above secondary diagonal
class GFG
{
    public static void main(String[] args)
    {
        int[][] matrix = new int[5][5];
        int row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                System.out.printf("%d\t",
                           matrix[row_index][column_index]);
            }

            System.out.printf("\n");
        }

        // Print the elements above secondary diagonal
        System.out.printf("\nElements above Secondary" +
                                    " diagonal are:\n");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {

                // check for elements above secondary diagonal
                if ((row_index + column_index) < size - 1)
                    System.out.printf("%d, ",
                               matrix[row_index][column_index]);
            }
        }

    }
}

// This code is contributed by Rajput-Ji

Python3

# Python3 Program to read a square matrix
# and print the elements above secondary diagonal

if __name__ == '__main__':
    matrix = [[0 for i in range(5)] for j in range(5)];
    row_index, column_index, x, size = 0, 0, 0, 5;

    # Get the square matrix
    for row_index in range(size):
        for column_index in range(size):
            x += 1;
            matrix[row_index][column_index] += x;

    # Display the matrix
    print("The matrix is");
    for row_index in range(size):
        for column_index in range(size):
            print( matrix[row_index][column_index], end = "\t");
        print("");

    # Print the elements above secondary diagonal
    print("\nElements above Secondary diagonal are:");

    for row_index in range(size):
        for column_index in range(size):

            # check for elements above secondary diagonal
            if ((row_index + column_index) < size - 1):
                print(matrix[row_index][column_index], end=" ");

# This code is contributed by 29AjayKumar

C#

// C# Program to read a square matrix
// and print the elements above
// secondary diagonal
using System;

class GFG
{
    public static void Main(String[] args)
    {
        int[,] matrix = new int[5, 5];
        int row_index, column_index,
                    x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0;
              row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size;
                 column_index++)
            {
                matrix[row_index,
                       column_index] = ++x;
            }
        }

        // Display the matrix
        Console.Write("The matrix is\n");
        for (row_index = 0;
            row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size;
                 column_index++)
            {
                Console.Write("{0}\t",
                        matrix[row_index,
                               column_index]);
            }
            Console.Write("\n");
        }

        // Print the elements above
        // secondary diagonal
        Console.Write("\nElements above Secondary" +
                                " diagonal are:\n");

        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {

                // check for elements above
                // secondary diagonal
                if ((row_index + column_index) < size - 1)
                    Console.Write("{0}, ",
                            matrix[row_index,
                                   column_index]);
            }
        }

    }
}

// This code is contributed by Rajput-Ji

Javascript

<script>

// JavaScript Program to read a square matrix
// and print the elements above secondary diagonal

        let matrix = new Array(5);
        for(let i=0;i<5;i++)
        {
            matrix[i]=new Array(5);

        }
        let row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        document.write("The matrix is<br>");
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                document.write("   ",
                           matrix[row_index][column_index]);
            }

            document.write("<br>");
        }

        // Print the elements above secondary diagonal
        document.write("<br>Elements above Secondary" +
                                    " diagonal are:<br>");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {

                // check for elements above secondary diagonal
                if ((row_index + column_index) < size - 1)
                 document.write(matrix[row_index][column_index]+", ");
            }
        }



// This code is contributed by ab2127

</script>

Output

The matrix is
1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20 
21 22 23 24 25 

Elements above Secondary diagonal are:
1, 2, 3, 4, 6, 7, 8, 11, 12, 16, 

• Elements below the secondary diagonal: 

Approach:

(row_index + column_index) > size-1

Implementation:

C++

// C Program to read a square matrix
// and print the elements below secondary diagonal

#include <bits/stdc++.h>
using namespace std;

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout << "The matrix is\n";
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout << " " << matrix[row_index][column_index] << " ";
        }

        cout << endl ;
    }

    // Print the elements below secondary diagonal
    cout << "\nElements below Secondary diagonal are:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements below secondary diagonal
            if ((row_index + column_index) > size - 1)
                cout << matrix[row_index][column_index] << " , ";
        }
    }

    return 0;
}

//This code is contributed by shivanisinghss2110

C

// C Program to read a square matrix
// and print the elements below secondary diagonal

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the elements below secondary diagonal
    printf("\nElements below Secondary diagonal are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for elements below secondary diagonal
            if ((row_index + column_index) > size - 1)
                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

// Java Program to read a square matrix
// and print the elements below secondary diagonal
class GFG
{
    public static void main(String[] args)
    {
        int[][] matrix = new int[5][5];
        int row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                System.out.printf("%d\t",
                           matrix[row_index][column_index]);
            }

            System.out.printf("\n");
        }

        // Print the elements below secondary diagonal
        System.out.printf("\nElements below Secondary" +
                                    " diagonal are:\n");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {

                // check for elements below secondary diagonal
                if ((row_index + column_index) > size - 1)
                    System.out.printf("%d, ",
                               matrix[row_index][column_index]);
            }
        }

    }
}

// This code is contributed by 29AjayKumar

Python3

# Python3 Program to read a square matrix
# and print the elements below secondary diagonal

if __name__ == '__main__':
    matrix = [[0 for i in range(5)] for j in range(5)]
row_index, column_index, x, size = 0, 0, 0, 5;

# Get the square matrix
for row_index in range(size):
    for column_index in range(size):
        x += 1;
        matrix[row_index][column_index] = x;

# Display the matrix
print("The matrix is");
for row_index in range(size):
    for column_index in range(size):
        print(matrix[row_index][column_index], end="\t");
    print("");

# Print the elements below secondary diagonal
print("\nElements below Secondary diagonal are:");

for row_index in range(size):
    for column_index in range(size):

        # check for elements below secondary diagonal
        if ((row_index + column_index) > size - 1):
            print(matrix[row_index][column_index], end=", ");

# This code is contributed by 29AjayKumar

C#

// C# Program to read a square matrix
// and print the elements below secondary diagonal
using System;

class GFG
{
    public static void Main(String[] args)
    {
        int[,] matrix = new int[5, 5];
        int row_index, column_index,
                    x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                matrix[row_index, column_index] = ++x;
            }
        }

        // Display the matrix
        Console.Write("The matrix is\n");
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                column_index < size; column_index++)
            {
                Console.Write("{0}\t",
                        matrix[row_index, column_index]);
            }

            Console.Write("\n");
        }

        // Print the elements below secondary diagonal
        Console.Write("\nElements below Secondary" +
                                " diagonal are:\n");

        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                column_index < size; column_index++)
            {

                // check for elements below secondary diagonal
                if ((row_index + column_index) > size - 1)
                    Console.Write("{0}, ", matrix[row_index,
                                             column_index]);
            }
        }

    }
}

// This code is contributed by 29AjayKumar

Javascript

<script>

        let matrix = new Array(5);
        for(let i=0;i<5;i++)
        {
            matrix[i]=new Array(5);
            for(let j=0;j<5;j++)
                matrix[i][j]=0;
        }
        let row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0;
             row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        document.write("The matrix is<br>");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {
                document.write(
                           matrix[row_index][column_index]+"   ");
            }

            document.write("<br>");
        }

        // Print the elements below secondary diagonal
        document.write("<br>Elements below Secondary" +
                                    " diagonal are:<br>");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0;
                 column_index < size; column_index++)
            {

                // check for elements below secondary diagonal
                if ((row_index + column_index) > size - 1)
                    document.write(
                               matrix[row_index][column_index]+", ");
            }
        }

// This code is contributed by rag2127
</script>

Output

The matrix is
 1  2  3  4  5 
 6  7  8  9  10 
 11  12  13  14  15 
 16  17  18  19  20 
 21  22  23  24  25 

Elements below Secondary diagonal are:
10 , 14 , 15 , 18 , 19 , 20 , 22 , 23 , 24 , 25 , 

• Corner elements: 

Approach:

( row_index == 0 || row_index == size-1 )
    &&
( column_index == 0 || column_index == size-1 )

Implementation:

C++

// C++ Program to read a square matrix
// and print the Corner Elements

#include <bits/stdc++.h>
using namespace std;


int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout <<"The matrix is"<< endl;
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            cout << "\t" << matrix[row_index][column_index];
        }

        cout << endl;
    }

    // Print the Corner elements
    cout <<"\nCorner Elements are:\n";

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for corner elements
            if ((row_index == 0 || row_index == size - 1)
                && (column_index == 0 || column_index == size - 1))

                cout <<  matrix[row_index][column_index] << ",";
        }
    }

    return 0;
}
// This code is contributed by shivanisinghss2110

C

// C Program to read a square matrix
// and print the Corner Elements

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the Corner elements
    printf("\nCorner Elements are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for corner elements
            if ((row_index == 0 || row_index == size - 1)
                && (column_index == 0 || column_index == size - 1))

                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

// Java Program to read a square matrix
// and print the Corner Elements

class GFG
{
    public static void main(String[] args)
    {

        int [][]matrix = new int[5][5];
        int row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {
                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                System.out.printf("%d\t", matrix[row_index][column_index]);
            }
            System.out.printf("\n");
        }

        // Print the Corner elements
        System.out.printf("\nCorner Elements are:\n");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                // check for corner elements
                if ((row_index == 0 || row_index == size - 1)
                    && (column_index == 0 || column_index == size - 1))

                    System.out.printf("%d, ", matrix[row_index][column_index]);
            }
        }
    }
}

// This code is contributed by Rajput-Ji

Python3

# Python3 Program to read a square matrix
# and print the Corner Elements
if __name__ == '__main__':

    matrix = [[0 for i in range(5)] for j in range(5)]
    row_index, column_index, x, size = 0, 0, 0, 5;

    # Get the square matrix
    for row_index in range(size):
        for column_index in range(size):
            x += 1;
            matrix[row_index][column_index] = x;

    # Display the matrix
    print("The matrix is");
    for row_index in range(size):
        for column_index in range(size):
            print(matrix[row_index][column_index], end = "\t");
        print("");

    # Print the Corner elements
    print("\nCorner Elements are:");

    for row_index in range(size):
        for column_index in range(size):

            # check for corner elements
            if ((row_index == 0 or row_index == size - 1) and
                (column_index == 0 or column_index == size - 1)):
                print(matrix[row_index][column_index], end="\t");

# This code is contributed by 29AjayKumar

C#

// C# Program to read a square matrix
// and print the Corner Elements
using System;

class GFG
{
public static void Main(String[] args)
{
    int [,]matrix = new int[5, 5];
    int row_index,
        column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size; column_index++)
        {
            matrix[row_index, column_index] = ++x;
        }
    }

    // Display the matrix
    Console.Write("The matrix is\n");
    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size; column_index++)
        {

            Console.Write("{0}\t", matrix[row_index,
                                          column_index]);
        }
        Console.Write("\n");
    }

    // Print the Corner elements
    Console.Write("\nCorner Elements are:\n");

    for (row_index = 0; row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size; column_index++)
        {

            // check for corner elements
            if ((row_index == 0 || row_index == size - 1) &&
                (column_index == 0 || column_index == size - 1))

                Console.Write("{0}, ", matrix[row_index,
                                              column_index]);
        }
    }
}
}

// This code is contributed by PrinciRaj1992

Javascript

<script>

// javascript Program to read a square matrix
// and print the Corner Elements


        var matrix = Array(5).fill(0).map(x => Array(5).fill(0));
        var row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {
                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        document.write("The matrix is<br>");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                document.write(
                           matrix[row_index][column_index]+"   ");
            }
            document.write("<br>");
        }

        // Print the Corner elements
        document.write("<br>Elements below Secondary" +
                                    " diagonal are:<br>");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                // check for corner elements
                if ((row_index == 0 || row_index == size - 1)
                    && (column_index == 0 || column_index == size - 1))

                     document.write(
                               matrix[row_index][column_index]+", ");
            }
        }

// This code is contributed by 29AjayKumar
</script>

Output

The matrix is
    1    2    3    4    5
    6    7    8    9    10
    11    12    13    14    15
    16    17    18    19    20
    21    22    23    24    25

Corner Elements are:
1,5,21,25,

• Boundary elements: 

Approach:

( row_index == 0 || row_index == size-1 ||
 column_index == 0 || column_index == size-1 )

Implementation:

C++

// C++ Program to read a square matrix
// and print the Boundary Elements
#include <bits/stdc++.h>
using namespace std;

int main()
{

    int matrix[5][5], row_index,
        column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size;
             column_index++)
        {
            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    cout << "The matrix is\n";
    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size;
             column_index++)
        {
            cout <<"\t"
                 << matrix[row_index][column_index];
        }

        cout << endl;
    }

    // Print the Boundary elements
    cout << "\nBoundary Elements are:\n";

    for (row_index = 0;
         row_index < size; row_index++)
    {
        for (column_index = 0;
             column_index < size;
             column_index++)
        {

            // check for boundary elements
            if ((row_index == 0 ||
                 row_index == size - 1 ||
                 column_index == 0 ||
                 column_index == size - 1))

                cout << matrix[row_index][column_index]
                     << ", " ;
        }
    }
    return 0;
}

// This code is contributed by shivanisinghss2110

C

// C Program to read a square matrix
// and print the Boundary Elements

#include <stdio.h>

int main()
{

    int matrix[5][5], row_index, column_index, x = 0, size = 5;

    // Get the square matrix
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            matrix[row_index][column_index] = ++x;
        }
    }

    // Display the matrix
    printf("The matrix is\n");
    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            printf("%d\t", matrix[row_index][column_index]);
        }

        printf("\n");
    }

    // Print the Boundary elements
    printf("\nBoundary Elements are:\n");

    for (row_index = 0; row_index < size; row_index++) {
        for (column_index = 0; column_index < size; column_index++) {

            // check for boundary elements
            if ((row_index == 0
                 || row_index == size - 1
                 || column_index == 0
                 || column_index == size - 1))

                printf("%d, ", matrix[row_index][column_index]);
        }
    }

    return 0;
}

Java

//Java Program to read a square matrix
// and print the Boundary Elements

class GFG {

    public static void main(String[] args) {

        int matrix[][] = new int[5][5], row_index, column_index, x = 0, size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                matrix[row_index][column_index] = ++x;
            }
        }

        // Display the matrix
        System.out.printf("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                System.out.printf("%d\t", matrix[row_index][column_index]);
            }

            System.out.printf("\n");
        }

        // Print the Boundary elements
        System.out.printf("\nBoundary Elements are:\n");

        for (row_index = 0; row_index < size; row_index++) {
            for (column_index = 0; column_index < size; column_index++) {

                // check for boundary elements
                if ((row_index == 0
                        || row_index == size - 1
                        || column_index == 0
                        || column_index == size - 1)) {
                    System.out.printf("%d, ", matrix[row_index][column_index]);
                }
            }
        }

    }
}
// This code is contributed by 29AjayKumar

Python3

# Python3 Program to read a square matrix
# and print the Boundary Elements
if __name__ == '__main__':

    matrix = [[0 for i in range(5)] for j in range(5)]
    row_index, column_index, x, size = 0, 0, 0, 5;

    # Get the square matrix
    for row_index in range(size):
        for column_index in range(size):
            x += 1;
            matrix[row_index][column_index] = x;

    # Display the matrix
    print("The matrix is");
    for row_index in range(size):
        for column_index in range(size):
            print(matrix[row_index]
                        [column_index], end = "\t");
        print("");

    # Print the Boundary elements
    print("\nBoundary Elements are:");

    for row_index in range(size):
        for column_index in range(size):

            # check for boundary elements
            if ((row_index == 0 or
                row_index == size - 1 \
                or column_index == 0 or
                column_index == size - 1)):
                print(matrix[row_index]
                            [column_index], end = ", ");

# This code is contributed by 29AjayKumar

C#

// C# Program to read a square matrix
// and print the Boundary Elements
using System;

class GFG
{
    static public void Main ()
    {
        int [,]matrix = new int[5,5];
        int row_index;
        int column_index;
        int x = 0;
        int size = 5;

        // Get the square matrix
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                matrix[row_index,column_index] = ++x;
            }
        }

        // Display the matrix
        Console.Write("The matrix is\n");
        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                Console.Write("{0}\t", matrix[row_index,column_index]);
            }

            Console.Write("\n");
        }

        // Print the Boundary elements
        Console.Write("\nBoundary Elements are:\n");

        for (row_index = 0; row_index < size; row_index++)
        {
            for (column_index = 0; column_index < size; column_index++)
            {

                // check for boundary elements
                if ((row_index == 0
                        || row_index == size - 1
                        || column_index == 0
                        || column_index == size - 1)) {
                    Console.Write("{0},", matrix[row_index,column_index]);
                }
            }
        }

    }
}

// This code is contributed by ajit.

Javascript

// JavaScript Program to read a square matrix
// and print the Boundary Elements

let matrix = new Array(5);
for (var i = 0; i < 5; i++)
    matrix[i] = new Array(5);

let row_index = 0, column_index = 0, x = 0, size = 5;

// Get the square matrix
for (row_index = 0; row_index < 5; row_index++) {
    for (column_index = 0; column_index < 5;
         column_index++) {
        x += 1;
        matrix[row_index][column_index] = x;
    }
}

// Display the matrix
console.log("The matrix is");
for (row_index = 0; row_index < 5; row_index++) {
    for (column_index = 0; column_index < 5; column_index++)
        process.stdout.write(matrix[row_index][column_index]
                             + "\t");
    process.stdout.write("\n");
}

// Print the Boundary elements
console.log("\nBoundary Elements are:");

for (row_index = 0; row_index < 5; row_index++) {
    for (column_index = 0; column_index < 5;
         column_index++) {
        // check for boundary elements
        if ((row_index == 0 || row_index == size - 1
             || column_index == 0
             || column_index == size - 1))
            process.stdout.write(
                matrix[row_index][column_index] + ", ");
    }
}

// This code is contributed by phasing17

Output

The matrix is
    1    2    3    4    5
    6    7    8    9    10
    11    12    13    14    15
    16    17    18    19    20
    21    22    23    24    25

Boundary Elements are:
1, 2, 3, 4, 5, 6, 10, 11, 15, 16, 20, 21, 22, 23, 24, 25, 

Complexity Analysis:

• Time Complexity: O(N*N) where N is the size of the square matrix
• Auxiliary Space: O(N*N) where N is the size of the square matrix.