How to access elements of a Square Matrix

23 Jan, 2022
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: 
1. Elements on the main diagonal: 
Approach:
row_index == column_index
C++
C
Java
Python3
C#
Javascript
// 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 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 Program to read a square matrix// and print the main diagonal elementsclass 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
# 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# Program to read a square matrix// and print the main diagonal elementsusing 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
<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>
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 the main diagonal: 
Approach: 
row_index < column_index
C++
C
Java
Python3
C#
Javascript
// 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 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 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 Program to read a square matrix# and print the elements above main diagonalif __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# 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
<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>
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 the main diagonal: 
Approach: 
row_index > column_index
C++
C
Java
Python3
C#
Javascript
// 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 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;}
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
# 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# program of above approachusing 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
<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>
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 the secondary diagonal:  
Approach: 
(row_index + column_index) == size-1
C++
C
Java
C#
Javascript
// 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 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  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# Program to read a square matrix// and print the elements on secondary diagonalusing 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
<script> // Javascript  Program to read a square matrix// and print the elements on secondary diagonallet 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 matrixfor(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 matrixdocument.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 diagonaldocument.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>
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 the secondary diagonal :  
Approach: 
(row_index + column_index) < size-1
C++
C
Java
Python3
C#
Javascript
// 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 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 Program to read a square matrix// and print the elements above secondary diagonalclass 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 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# Program to read a square matrix// and print the elements above// secondary diagonalusing 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
<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>
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 the secondary diagonal:  
Approach:
(row_index + column_index) > size-1
C++
C
Java
Python3
C#
Javascript
// 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 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 Program to read a square matrix// and print the elements below secondary diagonalclass 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 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 matrixfor row_index in range(size):    for column_index in range(size):        x += 1;        matrix[row_index][column_index] = x; # Display the matrixprint("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 diagonalprint("\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# Program to read a square matrix// and print the elements below secondary diagonalusing 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
<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>
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++
C
Java
Python3
C#
Javascript
// 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 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 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 Program to read a square matrix# and print the Corner Elementsif __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# Program to read a square matrix// and print the Corner Elementsusing 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
<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>
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++
C
Java
Python3
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 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 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 Program to read a square matrix# and print the Boundary Elementsif __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# Program to read a square matrix// and print the Boundary Elementsusing 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.
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,
 
 
 
29AjayKumar
princiraj1992
Rajput-Ji
jit_t
SHUBHAMSINGH10
shivanisinghss2110
Code_Mech
ukasp
rag2127
avanitrachhadiya2155
patel2127
unknown2108
ab2127
surindertarika1234
simranarora5sos
Arrays
Technical Scripter 2018
Arrays
Mathematical
Matrix
Technical Scripter
Arrays
Mathematical
Matrix
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Window Sliding Technique
Search, insert and delete in an unsorted array
What is Data Structure: Types, Classifications and Applications
Chocolate Distribution Problem
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
Write a program to print all permutations of a given string
C++ Data Types
Coin Change | DP-7