How to access elements of a Square Matrix

A square matrix is a matrix in which contains 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:

  1. Elements on main diagonal:

    Approach:



    row_index == column_index

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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 

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    //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

    chevron_right

    
    

    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, 
    
  2. Elements above main diagonal:

    Approach:

    row_index < column_index

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

          
    // 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

    chevron_right

    
    

    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,
    
  3. Elements below main diagonal:

    Approach:

    row_index > column_index

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    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 

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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=", ")

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // C# program of above approach 
    using System; 
    public class GFG { 
      
    // Java Program to read a suare 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

    chevron_right

    
    

    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,
    
  4. Elements on secondary diagonal:



    Approach:

    (row_index + column_index) == size-1

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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.

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    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,
    
  5. Address of elements above secondary diagonal :

    Approach:

    (row_index + column_index) < size-1

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    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,
    
  6. Elements below secondary diagonal:

    Approach:

    (row_index + column_index) > size-1

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    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,
    
  7. Corner elements:

    Approach:

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

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    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,
    
  8. Boundary elements:

    Approach:

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

    C++

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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

    chevron_right

    
    

    C

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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;
    }

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    //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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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.

    chevron_right

    
    

    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,
    

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.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.