Given a matrix M[][] of dimensions N * N, consisting only of integers from the range 1 to N, the task is to compute the sum of the matrix elements present in the main diagonal, the number of rows and columns containing repeated values.
Examples:
Input: N = 4, M[][] = {{1, 2, 3, 4}, {2, 1, 4, 3}, {3, 4, 1, 2}, {4, 3, 2, 1}}
Output: 4 0 0
Explanation:
Sum of diagonal = M[0][0] + M[1][1] + M[2][2] + M[3][3] = 4.
No row or column consists of repeated elements.
Therefore, the required sum is 4Input: N = 3, M[][] = {{2, 1, 3}, {1, 3, 2}, {1, 2, 3}}
Output: 8 0 2
Explanation:
Sum of diagonal = M[0][0]+M[1][1]+M[2][2] = 8.
No row consists of repeated elements.
1st and 3rd columns consists of repeated elements.
Approach 1: The approach is to simply traverse all elements of the matrix and find the sum of diagonals and the number of rows and columns having repeated values. Follow the steps below to solve the given problem:
- Initialize variables trace, rowRepeat, and columnRepeat to store the sum of the main diagonal, the number of rows, and columns containing repeated matrix elements respectively.
- Traverse through each element present in the matrix M[i][j] and increment the sum trace if i is equal to j.
- To find rows containing repeated values, iterate over one row at a time, compare values, and check if there exists a repeated value or not. On getting the first pair of repeat element, increment rowRepeat by 1 and break out of the loop.
- Repeat the above steps for every row of the matrix.
- The same procedure is repeated for all columns, where columnRepeat is incremented by 1 if the values match.
- After completing all the iterations, print the value of trace, rowRepeat, and columnRepeat as the result.
Below is the implementation of the above approach:
// C++14 program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to calculate trace of // a matrix and number of rows and // columns with repeated elements void vestigium( int N, int M[4][4])
{ // Stores the trace, number of
// rows and columns consisting
// of repeated matrix elements
int trace = 0, row_repeat = 0;
int column_repeat = 0;
// Iterate over the matrix
for ( int i = 0; i < N; i++)
{
for ( int j = 0; j < N; j++)
{
// If current element is
// present in the main diagonal
if (i == j)
{
// Update trace
trace += M[i][j];
}
}
int flag1 = 0;
// Iterate over each row
// and increment row_repeat
// if repeated values exists
for ( int j = 0; j < N; j++)
{
for ( int k = 0; k < N; k++)
{
// For each valid range
if (j != k && M[i][j] == M[i][k])
{
row_repeat++;
flag1 = 1;
break ;
}
}
if (flag1 == 1)
{
break ;
}
}
int flag2 = 0;
// Iterate over each column and
// increment column_repeat if
// repeated values are encountered
for ( int j = 0; j < N; j++)
{
for ( int k = 0; k < N; k++)
{
// For each valid range
if (j != k && M[j][i] == M[k][i])
{
column_repeat++;
flag2 = 1;
break ;
}
}
if (flag2 == 1)
{
break ;
}
}
}
// Answer
cout << trace << " "
<< row_repeat << " "
<< column_repeat ;
} // Driver Code int main()
{ int M[4][4] = { { 1, 2, 3, 4 },
{ 2, 1, 4, 3 },
{ 3, 4, 1, 2 },
{ 4, 3, 2, 1 } };
int N = sizeof (M) / sizeof (M[0]);
vestigium(N, M);
} // This code is contributed by sanjoy_62 |
// Java program for the above approach public class GFG {
// Function to calculate trace of
// a matrix and number of rows and
// columns with repeated elements
public static String vestigium(
int N, int M[][])
{
// Stores the trace, number of
// rows and columns consisting
// of repeated matrix elements
int trace = 0 , row_repeat = 0 ;
int column_repeat = 0 ;
// Iterate over the matrix
for ( int i = 0 ; i < N; i++) {
for ( int j = 0 ; j < N; j++) {
// If current element is
// present in the main diagonal
if (i == j) {
// Update trace
trace += M[i][j];
}
}
int flag1 = 0 ;
// Iterate over each row
// and increment row_repeat
// if repeated values exists
for ( int j = 0 ; j < N; j++) {
for ( int k = 0 ; k < N; k++) {
// For each valid range
if (j != k
&& M[i][j] == M[i][k]) {
row_repeat++;
flag1 = 1 ;
break ;
}
}
if (flag1 == 1 ) {
break ;
}
}
int flag2 = 0 ;
// Iterate over each column and
// increment column_repeat if
// repeated values are encountered
for ( int j = 0 ; j < N; j++) {
for ( int k = 0 ; k < N; k++) {
// For each valid range
if (j != k
&& M[j][i] == M[k][i]) {
column_repeat++;
flag2 = 1 ;
break ;
}
}
if (flag2 == 1 ) {
break ;
}
}
}
// Answer
String output = trace + " "
+ row_repeat + " "
+ column_repeat + "\n" ;
// Return answer
return output;
}
// Driver Code
public static void main(String[] args)
{
int M[][] = { { 1 , 2 , 3 , 4 },
{ 2 , 1 , 4 , 3 },
{ 3 , 4 , 1 , 2 },
{ 4 , 3 , 2 , 1 } };
int N = M.length;
String output = vestigium(N, M);
// Print the output
System.out.print(output);
}
} |
# Python3 program for the above approach # Function to calculate trace of # a matrix and number of rows and # columns with repeated elements def vestigium(N, M) :
# Stores the trace, number of
# rows and columns consisting
# of repeated matrix elements
trace = 0
row_repeat = 0
column_repeat = 0
# Iterate over the matrix
for i in range (N) :
for j in range (N) :
# If current element is
# present in the main diagonal
if (i = = j):
# Update trace
trace + = M[i][j]
flag1 = 0
# Iterate over each row
# and increment row_repeat
# if repeated values exists
for j in range (N) :
for k in range (N) :
# For each valid range
if (j ! = k and M[i][j] = = M[i][k]) :
row_repeat + = 1
flag1 = 1
break
if (flag1 = = 1 ) :
break
flag2 = 0
# Iterate over each column and
# increment column_repeat if
# repeated values are encountered
for j in range (N) :
for k in range (N) :
# For each valid range
if (j ! = k and M[j][i] = = M[k][i]) :
column_repeat + = 1
flag2 = 1
break
if (flag2 = = 1 ) :
break
# Answer
print (trace, row_repeat, column_repeat)
# Driver Code M = [[ 1 , 2 , 3 , 4 ],
[ 2 , 1 , 4 , 3 ],
[ 3 , 4 , 1 , 2 ],
[ 4 , 3 , 2 , 1 ]]
N = len (M)
vestigium(N, M) # This code is contributed by avijitmonald1998. |
// C# program for the above approach using System;
class GFG{
// Function to calculate trace of // a matrix and number of rows and // columns with repeated elements public static String vestigium( int N, int [,] M)
{ // Stores the trace, number of
// rows and columns consisting
// of repeated matrix elements
int trace = 0, row_repeat = 0;
int column_repeat = 0;
// Iterate over the matrix
for ( int i = 0; i < N; i++)
{
for ( int j = 0; j < N; j++)
{
// If current element is
// present in the main diagonal
if (i == j)
{
// Update trace
trace += M[i, j];
}
}
int flag1 = 0;
// Iterate over each row
// and increment row_repeat
// if repeated values exists
for ( int j = 0; j < N; j++)
{
for ( int k = 0; k < N; k++)
{
// For each valid range
if (j != k && M[i, j] == M[i, k])
{
row_repeat++;
flag1 = 1;
break ;
}
}
if (flag1 == 1)
{
break ;
}
}
int flag2 = 0;
// Iterate over each column and
// increment column_repeat if
// repeated values are encountered
for ( int j = 0; j < N; j++)
{
for ( int k = 0; k < N; k++)
{
// For each valid range
if (j != k && M[j, i] == M[k, i])
{
column_repeat++;
flag2 = 1;
break ;
}
}
if (flag2 == 1)
{
break ;
}
}
}
// Answer
string output = trace + " " + row_repeat + " " +
column_repeat + "\n" ;
// Return answer
return output;
} // Driver Code public static void Main( string [] args)
{ int [, ] M = { { 1, 2, 3, 4 },
{ 2, 1, 4, 3 },
{ 3, 4, 1, 2 },
{ 4, 3, 2, 1 } };
int N = M.GetLength(0);
string output = vestigium(N, M);
// Print the output
Console.Write(output);
} } // This code is contributed by ukasp |
<script> // javascript program for the above approach // Function to calculate trace of // a matrix and number of rows and // columns with repeated elements function vestigium( N , M)
{ // Stores the trace, number of
// rows and columns consisting
// of repeated matrix elements
var trace = 0, row_repeat = 0;
var column_repeat = 0;
// Iterate over the matrix
for (i = 0; i < N; i++) {
for (j = 0; j < N; j++) {
// If current element is
// present in the main diagonal
if (i == j) {
// Update trace
trace += M[i][j];
}
}
var flag1 = 0;
// Iterate over each row
// and increment row_repeat
// if repeated values exists
for (j = 0; j < N; j++) {
for (k = 0; k < N; k++) {
// For each valid range
if (j != k
&& M[i][j] == M[i][k]) {
row_repeat++;
flag1 = 1;
break ;
}
}
if (flag1 == 1) {
break ;
}
}
var flag2 = 0;
// Iterate over each column and
// increment column_repeat if
// repeated values are encountered
for (j = 0; j < N; j++) {
for (k = 0; k < N; k++) {
// For each valid range
if (j != k
&& M[j][i] == M[k][i]) {
column_repeat++;
flag2 = 1;
break ;
}
}
if (flag2 == 1) {
break ;
}
}
}
// Answer
var output = trace + " "
+ row_repeat + " "
+ column_repeat + "\n" ;
// Return answer
return output;
} // Driver Code var M = [ [ 1, 2, 3, 4 ],
[ 2, 1, 4, 3 ],
[ 3, 4, 1, 2 ],
[ 4, 3, 2, 1 ] ];
var N = M.length;
var output = vestigium(N, M);
// Print the output
document.write(output);
// This code contributed by shikhasingrajput </script> |
4 0 0
Time Complexity: O(N3)
Auxiliary Space: O(N2)
Approach 2:
- Create variables: trace, row_repeat, and column_repeat to zero.
- Initialize sets: row_set and column_set.
- Iterate through each row of the matrix using a loop.
- Clear row_set and column_set at the start of each row.
- Traverse elements in the current row and column.
- For diagonal elements (where i == j), add to trace.
- For each element in the row, check if it’s in row_set. If yes, increment row_repeat and break.
- For each element in the column, check if it’s in column_set. If yes, increment column_repeat and break.
- After all iterations, trace, row_repeat, and column_repeat are calculated.
- Print trace, row_repeat, and column_repeat.
Below is the implementation of the above approach:
// Approach Added by: Nikunj Sonigara #include <bits/stdc++.h> using namespace std;
void vestigium( int N, int M[4][4]) {
int trace = 0;
int row_repeat = 0;
int column_repeat = 0;
// Data structures to track repeated elements in rows and columns
unordered_set< int > row_set, column_set;
for ( int i = 0; i < N; i++) {
trace += M[i][i];
// Clear sets for each row and column
row_set.clear();
column_set.clear();
for ( int j = 0; j < N; j++) {
// Check for row repetitions
if (row_set.count(M[i][j]) > 0) {
row_repeat++;
break ;
}
row_set.insert(M[i][j]);
// Check for column repetitions
if (column_set.count(M[j][i]) > 0) {
column_repeat++;
break ;
}
column_set.insert(M[j][i]);
}
}
cout << trace << " " << row_repeat << " " << column_repeat;
} int main() {
int M[4][4] = {{1, 2, 3, 4},
{2, 1, 4, 3},
{3, 4, 1, 2},
{4, 3, 2, 1}};
int N = sizeof (M) / sizeof (M[0]);
vestigium(N, M);
return 0;
} |
// Approach Added by: Nikunj Sonigara import java.util.*;
public class Main {
public static void main(String[] args) {
int N = 4 ;
int [][] M = {
{ 1 , 2 , 3 , 4 },
{ 2 , 1 , 4 , 3 },
{ 3 , 4 , 1 , 2 },
{ 4 , 3 , 2 , 1 }
};
vestigium(N, M);
}
public static void vestigium( int N, int [][] M) {
int trace = 0 ;
int row_repeat = 0 ;
int column_repeat = 0 ;
// Data structures to track repeated elements in rows and columns
Set<Integer> rowSet = new HashSet<>();
Set<Integer> columnSet = new HashSet<>();
for ( int i = 0 ; i < N; i++) {
trace += M[i][i];
// Clear sets for each row and column
rowSet.clear();
columnSet.clear();
for ( int j = 0 ; j < N; j++) {
// Check for row repetitions
if (rowSet.contains(M[i][j])) {
row_repeat++;
break ;
}
rowSet.add(M[i][j]);
// Check for column repetitions
if (columnSet.contains(M[j][i])) {
column_repeat++;
break ;
}
columnSet.add(M[j][i]);
}
}
System.out.println(trace + " " + row_repeat + " " + column_repeat);
}
} |
# Approach Added by: Nikunj Sonigara def vestigium(N, M):
trace = 0
row_repeat = 0
column_repeat = 0
# Data structures to track repeated elements in rows and columns
row_set = set ()
column_set = set ()
for i in range (N):
trace + = M[i][i]
# Clear sets for each row and column
row_set.clear()
column_set.clear()
for j in range (N):
# Check for row repetitions
if M[i][j] in row_set:
row_repeat + = 1
break
row_set.add(M[i][j])
# Check for column repetitions
if M[j][i] in column_set:
column_repeat + = 1
break
column_set.add(M[j][i])
print (trace, row_repeat, column_repeat)
if __name__ = = "__main__" :
M = [
[ 1 , 2 , 3 , 4 ],
[ 2 , 1 , 4 , 3 ],
[ 3 , 4 , 1 , 2 ],
[ 4 , 3 , 2 , 1 ]
]
N = len (M)
vestigium(N, M)
|
using System;
using System.Collections.Generic;
class Program
{ static void Vestigium( int N, int [,] M)
{
int trace = 0;
int rowRepeat = 0;
int columnRepeat = 0;
// Data structures to track repeated elements in rows and columns
HashSet< int > rowSet = new HashSet< int >();
HashSet< int > columnSet = new HashSet< int >();
// Iterate through the matrix
for ( int i = 0; i < N; i++)
{
// Calculate the trace (sum of diagonal elements)
trace += M[i, i];
// Clear sets for each row and column
rowSet.Clear();
columnSet.Clear();
// Check for repeated elements in each row and column
for ( int j = 0; j < N; j++)
{
// Check for row repetitions
if (rowSet.Contains(M[i, j]))
{
rowRepeat++;
break ;
}
rowSet.Add(M[i, j]);
// Check for column repetitions
if (columnSet.Contains(M[j, i]))
{
columnRepeat++;
break ;
}
columnSet.Add(M[j, i]);
}
}
// Output the results
Console.WriteLine($ "{trace} {rowRepeat} {columnRepeat}" );
}
static void Main()
{
// Example matrix
int [,] M = { {1, 2, 3, 4},
{2, 1, 4, 3},
{3, 4, 1, 2},
{4, 3, 2, 1} };
int N = M.GetLength(0);
// Call the Vestigium function with the matrix and its size
Vestigium(N, M);
}
} |
function vestigium(N, M) {
let trace = 0;
let row_repeat = 0;
let column_repeat = 0;
// Data structures to track repeated elements in rows and columns
let rowSet = new Set();
let columnSet = new Set();
for (let i = 0; i < N; i++) {
trace += M[i][i];
// Clear sets for each row and column
rowSet.clear();
columnSet.clear();
for (let j = 0; j < N; j++) {
// Check for row repetitions
if (rowSet.has(M[i][j])) {
row_repeat++;
break ;
}
rowSet.add(M[i][j]);
// Check for column repetitions
if (columnSet.has(M[j][i])) {
column_repeat++;
break ;
}
columnSet.add(M[j][i]);
}
}
console.log(trace + " " + row_repeat + " " + column_repeat);
} // Example usage const N = 4; const M = [ [1, 2, 3, 4],
[2, 1, 4, 3],
[3, 4, 1, 2],
[4, 3, 2, 1]
]; vestigium(N, M); |
4 0 0
Time Complexity: O(N2)
Auxiliary Space: O(N)