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 5×5 matrix.
A 5×5 Square Matrix
A Matrix is accessed by: Matrix_Name[row_index][column_index]
Below are the various ways to access a Square Matrix in different forms:
- Elements on the main diagonal
Approach:
row_index == column_index
Implementation:
C++
#include <iostream>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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;
}
cout << "\nMain diagonal elements are:\n" ;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
if (row_index == column_index)
cout << matrix[row_index][column_index] << ", " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
printf ( "\nMain diagonal elements are:\n" );
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
if (row_index == column_index)
printf ( "%d, " , matrix[row_index][column_index]);
}
}
return 0;
}
|
Java
class GFG
{
public static void main(String[] args)
{
int matrix[][] = new int [ 5 ][ 5 ], row_index,
column_index, x = 0 , size = 5 ;
for (row_index = 0 ; row_index < size; row_index++)
{
for (column_index = 0 ; column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++)
{
if (row_index == column_index)
{
System.out.printf( "%d, " , matrix[row_index][column_index]);
}
}
}
}
}
|
Python3
if __name__ = = '__main__' :
matrix = [[ 0 for i in range ( 5 )] for j in range ( 5 )]
x, size = 0 , 5 ;
for row_index in range (size):
for column_index in range (size):
x + = 1 ;
matrix[row_index][column_index] = x;
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 ( "\nMain diagonal elements are:" );
for row_index in range (size):
for column_index in range (size):
if (row_index = = column_index):
print (matrix[row_index][column_index], end = "\t" );
|
C#
using System;
public class GFG{
public static void Main() {
int [,]matrix = new int [5,5];
int row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index,column_index] = ++x;
}
}
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();
}
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++) {
if (row_index == column_index) {
Console.Write(matrix[row_index,column_index]+ "," );
}
}
}
}
}
|
Javascript
<script>
let matrix = new Array(5), row_index,
column_index, x = 0, size = 5;
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;
}
}
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>" );
}
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++)
{
if (row_index == column_index)
{
document.write( matrix[row_index][column_index]
+ ", " );
}
}
}
</script>
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Main diagonal elements are:
1, 7, 13, 19, 25,
Complexity Analysis:
- Time Complexity: O(size * size)
- Auxiliary Space: O(size * size)
- Elements above the main diagonal:
Approach:
row_index < column_index
Implementation:
C++
#include <iostream>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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;
}
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++) {
if (row_index < column_index)
cout << matrix[row_index][column_index] << ", " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if (row_index < column_index)
printf ( "%d, " , matrix[row_index][column_index]);
}
}
return 0;
}
|
Java
class GFG {
public static void main(String args[]) {
int matrix[][] = new int [ 5 ][ 5 ], row_index, column_index, x = 0 , size = 5 ;
for (row_index = 0 ; row_index < size; row_index++) {
for (column_index = 0 ; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if (row_index < column_index) {
System.out.printf( "%d, " , matrix[row_index][column_index]);
}
}
}
}
}
|
Python3
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 ;
for row_index in range (size):
for column_index in range (size):
x + = 1 ;
matrix[row_index][column_index] = x;
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 ( "\nElements above Main diagonal elements are:" );
for row_index in range (size):
for column_index in range (size):
if (row_index < column_index):
print (matrix[row_index][column_index], end = " " );
|
C#
using System;
public class GFG {
public static void Main() {
int [,] matrix= new int [5,5];
int row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index,column_index] = ++x;
}
}
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" );
}
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++) {
if (row_index < column_index) {
Console.Write(matrix[row_index,column_index]+ ", " );
}
}
}
}
}
|
Javascript
<script>
let matrix = new Array(5), row_index, column_index,
x = 0, size = 5;
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;
}
}
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>" );
}
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++)
{
if (row_index < column_index) {
document.write( matrix[row_index]
[column_index]+ ", " );
}
}
}
</script>
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements above Main diagonal elements are:
2, 3, 4, 5, 8, 9, 10, 14, 15, 20,
- Elements below the main diagonal:
Approach:
row_index > column_index
Implementation:
C++
#include <iostream>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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;
}
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++) {
if (row_index > column_index)
cout << matrix[row_index][column_index]<< ", " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if (row_index > column_index)
printf ( "%d, " , matrix[row_index][column_index]);
}
}
return 0;
}
|
Java
class GFG {
public static void main(String[] args) {
int matrix[][] = new int [ 5 ][ 5 ], row_index, column_index, x = 0 , size = 5 ;
for (row_index = 0 ; row_index < size; row_index++) {
for (column_index = 0 ; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if (row_index > column_index) {
System.out.printf( "%d, " , matrix[row_index][column_index]);
}
}
}
}
}
|
Python3
if __name__ = = "__main__" :
matrix = [[ 0 for x in range ( 5 )] for y in range ( 5 )]
x = 0
size = 5
for row_index in range ( 0 , size):
for column_index in range ( 0 , size):
x + = 1
matrix[row_index][column_index] = x
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 ()
print ( "Elements below Main diagonal elements are:" )
for row_index in range ( 0 , size):
for column_index in range ( 0 , size):
if (row_index > column_index):
print (matrix[row_index][column_index], end = ", " )
|
C#
using System;
public class GFG {
public static void Main() {
int [,]matrix = new int [5,5]; int row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index,column_index] = ++x;
}
}
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" );
}
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++) {
if (row_index > column_index) {
Console.Write( "{0}, " , matrix[row_index,column_index]);
}
}
}
}
}
|
Javascript
<script>
let matrix = new Array(5);
for (let i = 0; i < 5; i++)
{
matrix[i] = new Array(5);
for (let j = 0; j < 5; j++)
{
matrix[i][j] = 0;
}
}
let row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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>" );
}
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++) {
if (row_index > column_index) {
document.write( matrix[row_index][column_index]+ ", " );
}
}
}
</script>
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements below Main diagonal elements are:
6, 11, 12, 16, 17, 18, 21, 22, 23, 24,
- Elements on the secondary diagonal:
Approach:
(row_index + column_index) == size-1
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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;
}
cout << "\nElements on Secondary diagonal:\n" ;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
if ((row_index + column_index) == size - 1)
cout << matrix[row_index][column_index]<< ", " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
printf ( "\nElements on Secondary diagonal:\n" );
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
if ((row_index + column_index) == size - 1)
printf ( "%d, " , matrix[row_index][column_index]);
}
}
return 0;
}
|
Java
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 ;
for (row_index = 0 ; row_index < size; row_index++) {
for (column_index = 0 ; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if ((row_index + column_index) == size - 1 )
System.out.printf( "%d, " , matrix[row_index][column_index]);
}
}
}
}
|
C#
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;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index, column_index] = ++x;
}
}
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" );
}
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++)
{
if ((row_index + column_index) == size - 1)
Console.Write( "{0}, " , matrix[row_index,
column_index]);
}
}
}
}
|
Javascript
<script>
let matrix = new Array(5);
for (let i = 0; i < 5; i++)
{
matrix[i] = new Array(5);
for (let j = 0; j < 5; j++)
{
matrix[i][j] = 0;
}
}
let row_index, column_index, x = 0, size = 5;
for (row_index = 0;
row_index < size;
row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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>" );
}
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++)
{
if ((row_index + column_index) == size - 1)
document.write(
matrix[row_index][column_index] + ", " );
}
}
</script>
|
Python3
matrix = []
for i in range ( 5 ):
matrix.append([ 0 for _ in range ( 5 )])
x = 0
size = 5
for row_index in range (size):
for column_index in range (size):
x + = 1
matrix[row_index][column_index] = x
print ( "The matrix is" )
for row_index in range (size):
print ( * matrix[row_index])
print ( "\nElements on Secondary diagonal:" )
for row_index in range (size):
for column_index in range (size):
if ((row_index + column_index) = = size - 1 ):
print (matrix[row_index][column_index], end = ", " , sep = "")
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements on Secondary diagonal:
5, 9, 13, 17, 21,
- Address of elements above the secondary diagonal :
Approach:
(row_index + column_index) < size-1
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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;
}
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++) {
if ((row_index + column_index) < size - 1)
cout << matrix[row_index][column_index]<< ", " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if ((row_index + column_index) < size - 1)
printf ( "%d, " , matrix[row_index][column_index]);
}
}
return 0;
}
|
Java
class GFG
{
public static void main(String[] args)
{
int [][] matrix = new int [ 5 ][ 5 ];
int row_index, column_index, x = 0 , size = 5 ;
for (row_index = 0 ;
row_index < size; row_index++)
{
for (column_index = 0 ;
column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++)
{
if ((row_index + column_index) < size - 1 )
System.out.printf( "%d, " ,
matrix[row_index][column_index]);
}
}
}
}
|
Python3
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 ;
for row_index in range (size):
for column_index in range (size):
x + = 1 ;
matrix[row_index][column_index] + = x;
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 ( "\nElements above Secondary diagonal are:" );
for row_index in range (size):
for column_index in range (size):
if ((row_index + column_index) < size - 1 ):
print (matrix[row_index][column_index], end = " " );
|
C#
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;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
matrix[row_index,
column_index] = ++x;
}
}
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" );
}
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++)
{
if ((row_index + column_index) < size - 1)
Console.Write( "{0}, " ,
matrix[row_index,
column_index]);
}
}
}
}
|
Javascript
<script>
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;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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>" );
}
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++)
{
if ((row_index + column_index) < size - 1)
document.write(matrix[row_index][column_index]+ ", " );
}
}
</script>
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements above Secondary diagonal are:
1, 2, 3, 4, 6, 7, 8, 11, 12, 16,
- Elements below the secondary diagonal:
Approach:
(row_index + column_index) > size-1
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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 ;
}
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++) {
if ((row_index + column_index) > size - 1)
cout << matrix[row_index][column_index] << " , " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if ((row_index + column_index) > size - 1)
printf ( "%d, " , matrix[row_index][column_index]);
}
}
return 0;
}
|
Java
class GFG
{
public static void main(String[] args)
{
int [][] matrix = new int [ 5 ][ 5 ];
int row_index, column_index, x = 0 , size = 5 ;
for (row_index = 0 ;
row_index < size; row_index++)
{
for (column_index = 0 ;
column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++)
{
if ((row_index + column_index) > size - 1 )
System.out.printf( "%d, " ,
matrix[row_index][column_index]);
}
}
}
}
|
Python3
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 ;
for row_index in range (size):
for column_index in range (size):
x + = 1 ;
matrix[row_index][column_index] = x;
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 ( "\nElements below Secondary diagonal are:" );
for row_index in range (size):
for column_index in range (size):
if ((row_index + column_index) > size - 1 ):
print (matrix[row_index][column_index], end = ", " );
|
C#
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;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index, column_index] = ++x;
}
}
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" );
}
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++)
{
if ((row_index + column_index) > size - 1)
Console.Write( "{0}, " , matrix[row_index,
column_index]);
}
}
}
}
|
Javascript
<script>
let matrix = new Array(5);
for (let i=0;i<5;i++)
{
matrix[i]= new Array(5);
for (let j=0;j<5;j++)
matrix[i][j]=0;
}
let row_index, column_index, x = 0, size = 5;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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>" );
}
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++)
{
if ((row_index + column_index) > size - 1)
document.write(
matrix[row_index][column_index]+ ", " );
}
}
</script>
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Elements below Secondary diagonal are:
10 , 14 , 15 , 18 , 19 , 20 , 22 , 23 , 24 , 25 ,
Approach:
( row_index == 0 || row_index == size-1 )
&&
( column_index == 0 || column_index == size-1 )
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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;
}
cout << "\nCorner Elements are:\n" ;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
if ((row_index == 0 || row_index == size - 1)
&& (column_index == 0 || column_index == size - 1))
cout << matrix[row_index][column_index] << "," ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
printf ( "\nCorner Elements are:\n" );
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
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
class GFG
{
public static void main(String[] args)
{
int [][]matrix = new int [ 5 ][ 5 ];
int row_index, column_index, x = 0 , size = 5 ;
for (row_index = 0 ; row_index < size; row_index++)
{
for (column_index = 0 ; column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++)
{
if ((row_index == 0 || row_index == size - 1 )
&& (column_index == 0 || column_index == size - 1 ))
System.out.printf( "%d, " , matrix[row_index][column_index]);
}
}
}
}
|
Python3
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 ;
for row_index in range (size):
for column_index in range (size):
x + = 1 ;
matrix[row_index][column_index] = x;
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 ( "\nCorner Elements are:" );
for row_index in range (size):
for column_index in range (size):
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" );
|
C#
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;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
matrix[row_index, column_index] = ++x;
}
}
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" );
}
Console.Write( "\nCorner Elements are:\n" );
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0;
column_index < size; column_index++)
{
if ((row_index == 0 || row_index == size - 1) &&
(column_index == 0 || column_index == size - 1))
Console.Write( "{0}, " , matrix[row_index,
column_index]);
}
}
}
}
|
Javascript
<script>
var matrix = Array(5).fill(0).map(x => Array(5).fill(0));
var row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0; column_index < size; column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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>" );
}
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++)
{
if ((row_index == 0 || row_index == size - 1)
&& (column_index == 0 || column_index == size - 1))
document.write(
matrix[row_index][column_index]+ ", " );
}
}
</script>
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Corner Elements are:
1,5,21,25,
Approach:
( row_index == 0 || row_index == size-1 ||
column_index == 0 || column_index == size-1 )
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int main()
{
int matrix[5][5], row_index,
column_index, x = 0, size = 5;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
matrix[row_index][column_index] = ++x;
}
}
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;
}
cout << "\nBoundary Elements are:\n" ;
for (row_index = 0;
row_index < size; row_index++)
{
for (column_index = 0;
column_index < size;
column_index++)
{
if ((row_index == 0 ||
row_index == size - 1 ||
column_index == 0 ||
column_index == size - 1))
cout << matrix[row_index][column_index]
<< ", " ;
}
}
return 0;
}
|
C
#include <stdio.h>
int main()
{
int matrix[5][5], row_index, column_index, x = 0, size = 5;
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
printf ( "\nBoundary Elements are:\n" );
for (row_index = 0; row_index < size; row_index++) {
for (column_index = 0; column_index < size; column_index++) {
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
class GFG {
public static void main(String[] args) {
int matrix[][] = new int [ 5 ][ 5 ], row_index, column_index, x = 0 , size = 5 ;
for (row_index = 0 ; row_index < size; row_index++) {
for (column_index = 0 ; column_index < size; column_index++) {
matrix[row_index][column_index] = ++x;
}
}
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" );
}
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++) {
if ((row_index == 0
|| row_index == size - 1
|| column_index == 0
|| column_index == size - 1 )) {
System.out.printf( "%d, " , matrix[row_index][column_index]);
}
}
}
}
}
|
Python3
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 ;
for row_index in range (size):
for column_index in range (size):
x + = 1 ;
matrix[row_index][column_index] = x;
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 ( "\nBoundary Elements are:" );
for row_index in range (size):
for column_index in range (size):
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 = ", " );
|
C#
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;
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0; column_index < size; column_index++)
{
matrix[row_index,column_index] = ++x;
}
}
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" );
}
Console.Write( "\nBoundary Elements are:\n" );
for (row_index = 0; row_index < size; row_index++)
{
for (column_index = 0; column_index < size; column_index++)
{
if ((row_index == 0
|| row_index == size - 1
|| column_index == 0
|| column_index == size - 1)) {
Console.Write( "{0}," , matrix[row_index,column_index]);
}
}
}
}
}
|
Javascript
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;
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;
}
}
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" );
}
console.log( "\nBoundary Elements are:" );
for (row_index = 0; row_index < 5; row_index++) {
for (column_index = 0; column_index < 5;
column_index++) {
if ((row_index == 0 || row_index == size - 1
|| column_index == 0
|| column_index == size - 1))
process.stdout.write(
matrix[row_index][column_index] + ", " );
}
}
|
Output
The matrix is
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25
Boundary Elements are:
1, 2, 3, 4, 5, 6, 10, 11, 15, 16, 20, 21, 22, 23, 24, 25,
Complexity Analysis:
- Time Complexity: O(N*N) where N is the size of the square matrix
- Auxiliary Space: O(N*N) where N is the size of the square matrix.
Share your thoughts in the comments
Please Login to comment...