How to access elements of a Square Matrix
Last Updated :
05 Sep, 2022
A square matrix is a matrix which includes elements in the form of Rows and Columns. Below is an example of a 5x5 matrix.
A 5x5 Square Matrix
A Matrix is accessed by: Matrix_Name[row_index][column_index]
Below are the various ways to access a Square Matrix in different forms:
- Elements on the main diagonal
Approach:
row_index == column_index
Implementation:
C++
// C++ Program to read a square matrix
// and print the main diagonal elements
#include <iostream>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is" << endl;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << matrix[row_index][column_index] << " ";
}
cout << endl;
}
// Print the main diagonal elements
cout << "\nMain diagonal elements are:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for main diagonal elements
if (row_index == column_index)
cout << matrix[row_index][column_index] << ", ";
}
}
return 0;
}
// This code is contributed by SHUBHAMSINGH10
// C 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 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
# 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 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
<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>
OutputThe matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Main diagonal elements are:
1, 7, 13, 19, 25,
Complexity Analysis:
- Time Complexity: O(size * size)
- Auxiliary Space: O(size * size)
- Elements above the main diagonal:
Approach:
row_index < column_index
Implementation:
C++
// C++ Program to read a square matrix
// and print the elements above main diagonal
#include <iostream>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << matrix[row_index][column_index] << " ";
}
cout << endl;
}
// Print the elements above main diagonal
cout<<"\nElements above Main diagonal elements are:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for elements above main diagonal
if (row_index < column_index)
cout << matrix[row_index][column_index] << ", ";
}
}
return 0;
}
//This code is contributed by shubhamsingh10
// C 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 diagonal
if __name__ == '__main__':
matrix = [[0 for i in range(5)] for j in range(5)];
row_index, column_index, x, size = 0, 0, 0, 5;
# Get the square matrix
for row_index in range(size):
for column_index in range(size):
x += 1;
matrix[row_index][column_index] = x;
# Display the matrix
print("The matrix is");
for row_index in range(size):
for column_index in range(size):
print( matrix[row_index][column_index], end = "\t");
print("");
# Print the elements above main diagonal
print("\nElements above Main diagonal elements are:");
for row_index in range(size):
for column_index in range(size):
# check for elements above main diagonal
if (row_index < column_index):
print(matrix[row_index][column_index], end=" ");
# This code is contributed by 29AjayKumar
// C# 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>
OutputThe matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements above Main diagonal elements are:
2, 3, 4, 5, 8, 9, 10, 14, 15, 20,
- Elements below the main diagonal:
Approach:
row_index > column_index
Implementation:
C++
// C++ Program to read a square matrix
// and print the elements below main diagonal
#include <iostream>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << matrix[row_index][column_index] <<" ";
}
cout << endl;
}
// Print the elements below main diagonal
cout << "\nElements below Main diagonal elements are:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for elements below main diagonal
if (row_index > column_index)
cout << matrix[row_index][column_index]<< ", ";
}
}
return 0;
}
//This code is contributed by shubhamsingh10
// C 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 approach
using System;
public class GFG {
// Java Program to read a square matrix
// and print the elements below main diagonal
public static void Main() {
int [,]matrix = new int[5,5]; int row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index,column_index] = ++x;
}
}
// Display the matrix
Console.Write("The matrix is\n");
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
Console.Write("{0}\t", matrix[row_index,column_index]);
}
Console.Write("\n");
}
// Print the elements below main diagonal
Console.Write("\nElements below Main diagonal elements are:\n");
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for elements below main diagonal
if (row_index > column_index) {
Console.Write("{0}, ", matrix[row_index,column_index]);
}
}
}
}
}
// This code is contributed by Rajput-Ji
<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>
OutputThe matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements below Main diagonal elements are:
6, 11, 12, 16, 17, 18, 21, 22, 23, 24,
- Elements on the secondary diagonal:
Approach:
(row_index + column_index) == size-1
Implementation:
C++
// C++ Program to read a square matrix
// and print the elements on secondary diagonal
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << matrix[row_index][column_index] << " ";
}
cout << endl;
}
// Print the elements on secondary diagonal
cout << "\nElements on Secondary diagonal:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for elements on secondary diagonal
if ((row_index + column_index) == size - 1)
cout << matrix[row_index][column_index]<< ", ";
}
}
return 0;
}
//This code is contributed by shubhamsingh10
// C 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 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
<script>
// Javascript Program to read a square matrix
// and print the elements on secondary diagonal
let matrix = new Array(5);
for(let i = 0; i < 5; i++)
{
matrix[i] = new Array(5);
for(let j = 0; j < 5; j++)
{
matrix[i][j] = 0;
}
}
let row_index, column_index, x = 0, size = 5;
// Get the square matrix
for(row_index = 0;
row_index < size;
row_index++)
{
for(column_index = 0;
column_index < size;
column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
document.write("The matrix is<br>");
for(row_index = 0;
row_index < size;
row_index++)
{
for(column_index = 0;
column_index < size;
column_index++)
{
document.write(matrix[row_index][column_index] +
"  ");
}
document.write("<br>");
}
// Print the elements on secondary diagonal
document.write("<br>Elements on Secondary diagonal:<br>");
for(row_index = 0; row_index < size; row_index++)
{
for(column_index = 0;
column_index < size;
column_index++)
{
// Check for elements on secondary diagonal
if ((row_index + column_index) == size - 1)
document.write(
matrix[row_index][column_index] + ", ");
}
}
// This code is contributed by unknown2108
</script>
# Python3 Program to read a square matrix
# and print the elements on secondary diagonal
matrix = []
for i in range(5):
matrix.append([0 for _ in range(5)])
x = 0
size = 5
# Get the square matrix
for row_index in range(size):
for column_index in range(size):
x += 1
matrix[row_index][column_index] = x
# Display the matrix
print("The matrix is")
for row_index in range(size):
print(*matrix[row_index])
# Print the elements on secondary diagonal
print("\nElements on Secondary diagonal:")
for row_index in range(size):
for column_index in range(size):
# Check for elements on secondary diagonal
if ((row_index + column_index) == size - 1):
print(matrix[row_index][column_index], end=", ", sep="")
# This code is contributed by unknown2108
OutputThe matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements on Secondary diagonal:
5, 9, 13, 17, 21,
- Address of elements above the secondary diagonal :
Approach:
(row_index + column_index) < size-1
Implementation:
C++
// C++ Program to read a square matrix
// and print the elements above secondary diagonal
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << matrix[row_index][column_index] << " ";
}
cout << endl;
}
// Print the elements above secondary diagonal
cout << "\nElements above Secondary diagonal are:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for elements above secondary diagonal
if ((row_index + column_index) < size - 1)
cout << matrix[row_index][column_index]<< ", ";
}
}
return 0;
}
// This code is contributed by shivanisinghss2110
// C 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 diagonal
class GFG
{
public static void main(String[] args)
{
int[][] matrix = new int[5][5];
int row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
System.out.printf("The matrix is\n");
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
System.out.printf("%d\t",
matrix[row_index][column_index]);
}
System.out.printf("\n");
}
// Print the elements above secondary diagonal
System.out.printf("\nElements above Secondary" +
" diagonal are:\n");
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
// check for elements above secondary diagonal
if ((row_index + column_index) < size - 1)
System.out.printf("%d, ",
matrix[row_index][column_index]);
}
}
}
}
// This code is contributed by Rajput-Ji
# Python3 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 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
<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>
OutputThe matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements above Secondary diagonal are:
1, 2, 3, 4, 6, 7, 8, 11, 12, 16,
- Elements below the secondary diagonal:
Approach:
(row_index + column_index) > size-1
Implementation:
C++
// C Program to read a square matrix
// and print the elements below secondary diagonal
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << " " << matrix[row_index][column_index] << " ";
}
cout << endl ;
}
// Print the elements below secondary diagonal
cout << "\nElements below Secondary diagonal are:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for elements below secondary diagonal
if ((row_index + column_index) > size - 1)
cout << matrix[row_index][column_index] << " , ";
}
}
return 0;
}
//This code is contributed by shivanisinghss2110
// C 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 diagonal
class GFG
{
public static void main(String[] args)
{
int[][] matrix = new int[5][5];
int row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
System.out.printf("The matrix is\n");
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
System.out.printf("%d\t",
matrix[row_index][column_index]);
}
System.out.printf("\n");
}
// Print the elements below secondary diagonal
System.out.printf("\nElements below Secondary" +
" diagonal are:\n");
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
// check for elements below secondary diagonal
if ((row_index + column_index) > size - 1)
System.out.printf("%d, ",
matrix[row_index][column_index]);
}
}
}
}
// This code is contributed by 29AjayKumar
# Python3 Program to read a square matrix
# and print the elements below secondary diagonal
if __name__ == '__main__':
matrix = [[0 for i in range(5)] for j in range(5)]
row_index, column_index, x, size = 0, 0, 0, 5;
# Get the square matrix
for row_index in range(size):
for column_index in range(size):
x += 1;
matrix[row_index][column_index] = x;
# Display the matrix
print("The matrix is");
for row_index in range(size):
for column_index in range(size):
print(matrix[row_index][column_index], end="\t");
print("");
# Print the elements below secondary diagonal
print("\nElements below Secondary diagonal are:");
for row_index in range(size):
for column_index in range(size):
# check for elements below secondary diagonal
if ((row_index + column_index) > size - 1):
print(matrix[row_index][column_index], end=", ");
# This code is contributed by 29AjayKumar
// C# 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
<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>
OutputThe 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 ,
Approach:
( row_index == 0 || row_index == size-1 )
&&
( column_index == 0 || column_index == size-1 )
Implementation:
C++
// C++ Program to read a square matrix
// and print the Corner Elements
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout <<"The matrix is"<< endl;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
cout << "\t" << matrix[row_index][column_index];
}
cout << endl;
}
// Print the Corner elements
cout <<"\nCorner Elements are:\n";
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
// check for corner elements
if ((row_index == 0 || row_index == size - 1)
&& (column_index == 0 || column_index == size - 1))
cout << matrix[row_index][column_index] << ",";
}
}
return 0;
}
// This code is contributed by shivanisinghss2110
// C 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 Elements
if __name__ == '__main__':
matrix = [[0 for i in range(5)] for j in range(5)]
row_index, column_index, x, size = 0, 0, 0, 5;
# Get the square matrix
for row_index in range(size):
for column_index in range(size):
x += 1;
matrix[row_index][column_index] = x;
# Display the matrix
print("The matrix is");
for row_index in range(size):
for column_index in range(size):
print(matrix[row_index][column_index], end = "\t");
print("");
# Print the Corner elements
print("\nCorner Elements are:");
for row_index in range(size):
for column_index in range(size):
# check for corner elements
if ((row_index == 0 or row_index == size - 1) and
(column_index == 0 or column_index == size - 1)):
print(matrix[row_index][column_index], end="\t");
# This code is contributed by 29AjayKumar
// C# 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
<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>
OutputThe 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, 
Approach:
( row_index == 0 || row_index == size-1 ||
column_index == 0 || column_index == size-1 )
Implementation:
C++
// C++ Program to read a square matrix
// and print the Boundary Elements
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index,
column_index, x = 0, size = 5;
// Get the square matrix
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
// Display the matrix
cout << "The matrix is\n";
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
cout <<"\t"
<< matrix[row_index][column_index];
}
cout << endl;
}
// Print the Boundary elements
cout << "\nBoundary Elements are:\n";
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
// check for boundary elements
if ((row_index == 0 ||
row_index == size - 1 ||
column_index == 0 ||
column_index == size - 1))
cout << matrix[row_index][column_index]
<< ", " ;
}
}
return 0;
}
// This code is contributed by shivanisinghss2110
// C 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 Elements
if __name__ == '__main__':
matrix = [[0 for i in range(5)] for j in range(5)]
row_index, column_index, x, size = 0, 0, 0, 5;
# Get the square matrix
for row_index in range(size):
for column_index in range(size):
x += 1;
matrix[row_index][column_index] = x;
# Display the matrix
print("The matrix is");
for row_index in range(size):
for column_index in range(size):
print(matrix[row_index]
[column_index], end = "\t");
print("");
# Print the Boundary elements
print("\nBoundary Elements are:");
for row_index in range(size):
for column_index in range(size):
# check for boundary elements
if ((row_index == 0 or
row_index == size - 1 \
or column_index == 0 or
column_index == size - 1)):
print(matrix[row_index]
[column_index], end = ", ");
# This code is contributed by 29AjayKumar
// C# Program to read a square matrix
// and print the Boundary Elements
using System;
class GFG
{
static public void Main ()
{
int [,]matrix = new int[5,5];
int row_index;
int column_index;
int x = 0;
int size = 5;
// Get the square matrix
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0; column_index < size; column_index++)
{
matrix[row_index,column_index] = ++x;
}
}
// Display the matrix
Console.Write("The matrix is\n");
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0; column_index < size; column_index++)
{
Console.Write("{0}\t", matrix[row_index,column_index]);
}
Console.Write("\n");
}
// Print the Boundary elements
Console.Write("\nBoundary Elements are:\n");
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0; column_index < size; column_index++)
{
// check for boundary elements
if ((row_index == 0
|| row_index == size - 1
|| column_index == 0
|| column_index == size - 1)) {
Console.Write("{0},", matrix[row_index,column_index]);
}
}
}
}
}
// This code is contributed by ajit.
// JavaScript Program to read a square matrix
// and print the Boundary Elements
let matrix = new Array(5);
for (var i = 0; i < 5; i++)
matrix[i] = new Array(5);
let row_index = 0, column_index = 0, x = 0, size = 5;
// Get the square matrix
for (row_index = 0; row_index < 5; row_index++) {
for (column_index = 0; column_index < 5;
column_index++) {
x += 1;
matrix[row_index][column_index] = x;
}
}
// Display the matrix
console.log("The matrix is");
for (row_index = 0; row_index < 5; row_index++) {
for (column_index = 0; column_index < 5; column_index++)
process.stdout.write(matrix[row_index][column_index]
+ "\t");
process.stdout.write("\n");
}
// Print the Boundary elements
console.log("\nBoundary Elements are:");
for (row_index = 0; row_index < 5; row_index++) {
for (column_index = 0; column_index < 5;
column_index++) {
// check for boundary elements
if ((row_index == 0 || row_index == size - 1
|| column_index == 0
|| column_index == size - 1))
process.stdout.write(
matrix[row_index][column_index] + ", ");
}
}
// This code is contributed by phasing17
OutputThe matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Boundary Elements are:
1, 2, 3, 4, 5, 6, 10, 11, 15, 16, 20, 21, 22, 23, 24, 25,
Complexity Analysis:
- Time Complexity: O(N*N) where N is the size of the square matrix
- Auxiliary Space: O(N*N) where N is the size of the square matrix.
Similar Reads
C Program to Print Boundary Elements of a Matrix Here, we will print the boundary elements of a matrix using a C program: Input : 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 Output : 1 2 3 4 1 4 1 4 1 2 3 4Approach:Traverse the matrix from start to end.Assign an outer loop to point to the row and the inner row to traverse the elements of the row.if the elemen
2 min read
Efficient method to store a Lower Triangular Matrix using Column-major mapping Given a lower triangular matrix Mat[][], the task is to store the matrix using column-major mapping. Lower Triangular Matrix: A Lower Triangular Matrix is a square matrix in which the lower triangular part of a matrix consists of non-zero elements and the upper triangular part consists of 0s. The Lo
10 min read
C Program for Identity Matrix Introduction to Identity Matrix : The dictionary definition of an Identity Matrix is a square matrix in which all the elements of the principal or main diagonal are 1's and all other elements are zeros. In the below image, every matrix is an Identity Matrix. In linear algebra, this is sometimes call
2 min read
Squares of Matrix Diagonal Elements Given an integer matrix mat[][] of odd dimensions, the task is to find the square of the elements of the Primary and Secondary diagonals.The Primary and Secondary diagonal matrix explanation is given below:Primary Diagonal Elements of a Matrix: The Primary Diagonal Elements are the ones that occur f
11 min read
Find sum of all Matrix elements Given a matrix mat[][], the task is to find the sum of all the elements of the matrix. Examples: Input: mat[][] = {{1, 2, 3}, {4, 5, 6}}Output: 21Explanation: Here sum of all element = 1 + 2 + 3 + 4 + 5 + 6 = 21 Input: mat[][] = {{4, 5, 3, 2}, {9, 5, 6, 2}, {1, 5, 3, 5}}Output: 50Explanation: Here s
5 min read