Given a matrix mat[][], the task is to count the number of rows in the matrix that consists of the same elements.
Examples:
Input: mat[][] = {{1, 1, 1}, {1, 2, 3}, {5, 5, 5}}
Output: 2
All the elements of the first row and all the elements of the third row are the same.Input: mat[][] = {{1, 2}, {4, 2}}
Output: 0
Approach: Set count = 0 and start traversing the matrix row by row and for a particular row, add every element of the row in a set and check if size(set) = 1, if yes then update count = count + 1.
After all the rows have been traversed, print the value of the count.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the count of all identical rows int countIdenticalRows(vector< vector < int > > mat)
{ int count = 0;
for ( int i = 0; i < mat.size(); i++)
{
// HashSet for current row
set< int > hs;
// Traverse the row
for ( int j = 0; j < mat[i].size(); j++)
{
// Add all the values of the row in HashSet
hs.insert(mat[i][j]);
}
// Check if size of HashSet = 1
if (hs.size() == 1)
count++;
}
return count;
} // Driver code int main()
{ vector< vector < int > > mat = {{ 1, 1, 1 },
{ 1, 2, 3 },
{ 5, 5, 5 }};
cout << countIdenticalRows(mat);
return 0;
} // This code is contributed by Rituraj Jain |
// Java implementation of the approach import java.util.HashSet;
class GFG {
// Function to return the count of all identical rows
public static int countIdenticalRows( int mat[][])
{
int count = 0 ;
for ( int i = 0 ; i < mat.length; i++) {
// HashSet for current row
HashSet<Integer> hs = new HashSet<>();
// Traverse the row
for ( int j = 0 ; j < mat[i].length; j++) {
// Add all the values of the row in HashSet
hs.add(mat[i][j]);
}
// Check if size of HashSet = 1
if (hs.size() == 1 )
count++;
}
return count;
}
// Driver code
public static void main(String[] args)
{
int mat[][] = { { 1 , 1 , 1 },
{ 1 , 2 , 3 },
{ 5 , 5 , 5 } };
System.out.print(countIdenticalRows(mat));
}
} |
#Function to return the count of all identical rows def countIdenticalRows(mat):
count = 0
for i in range ( len (mat)):
#HashSet for current row
hs = dict ()
#Traverse the row
for j in range ( len (mat[i])):
#Add all the values of the row in HashSet
hs[(mat[i][j])] = 1
#Check if size of HashSet = 1
if ( len (hs) = = 1 ):
count + = 1
return count
#Driver code mat = [ [ 1 , 1 , 1 ],
[ 1 , 2 , 3 ],
[ 5 , 5 , 5 ] ]
print (countIdenticalRows(mat))
#This code is contributed by Mohit kumar 29 |
// C# implementation of // the above approach using System;
using System.Collections.Generic;
class GFG
{ // Function to return the count
// of all identical rows
public static int countIdenticalRows( int [,]mat)
{
int count = 0;
for ( int i = 0;
i < mat.GetLength(0); i++)
{
// HashSet for current row
HashSet< int > hs = new HashSet< int >();
// Traverse the row
for ( int j = 0;
j < mat.GetLength(0); j++)
{
// Add all the values
// of the row in HashSet
hs.Add(mat[i, j]);
}
// Check if size of HashSet = 1
if (hs.Count == 1)
count++;
}
return count;
}
// Driver code
public static void Main(String[] args)
{
int [,]mat = {{ 1, 1, 1 },
{ 1, 2, 3 },
{ 5, 5, 5 }};
Console.WriteLine(countIdenticalRows(mat));
}
} // This code is contributed by Princi Singh |
// Function to return the count of all identical rows function countIdenticalRows(mat) {
let count = 0;
for (let i = 0; i < mat.length; i++) {
// Set for current row
let set = new Set();
// Traverse the row
for (let j = 0; j < mat[i].length; j++) {
// Add all the values of the row in Set
set.add(mat[i][j]);
}
// Check if size of Set = 1
if (set.size === 1) {
count++;
}
}
return count;
} // Driver code const mat = [[1, 1, 1], [1, 2, 3], [5, 5, 5]]; console.log(countIdenticalRows(mat)); |
2
Complexity Analysis:
- Time Complexity: O(N*M*logM), as we are using nested loops for traversing N*M times. Where N and M are the number of rows and columns respectively.
- Auxiliary Space: O(M), as we are using extra space for the set of size M. Where M is the number of columns in the matrix.
Memory efficient approach: Set count = 0 and start traversing the matrix row by row and, for a particular row, save the first element of the row in a variable first and compare all the other elements with first. If all the other elements of the row are equal to the first element, then update count = count + 1. When all the rows have been traversed, print the count.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the count of all identical rows
int countIdenticalRows( int mat[3][3], int r, int c)
{
int count = 0;
for ( int i = 0; i < r; i++)
{
// First element of current row
int first = mat[i][0];
bool allSame = true ;
// Compare every element of the current row
// with the first element of the row
for ( int j = 1; j < c; j++)
{
// If any element is different
if (mat[i][j] != first)
{
allSame = false ;
break ;
}
}
// If all the elements of the
// current row were same
if (allSame)
count++;
}
return count;
}
// Driver code
int main()
{
//int mat[3][3] ;
int mat[][3] = { { 1, 1, 2 },
{ 2, 2, 2 },
{ 5, 5, 2 } };
int row_length = sizeof (mat)/ sizeof (mat[0]) ;
int col_length = sizeof (mat[0])/ sizeof ( int ) ;
cout << countIdenticalRows(mat, row_length,col_length) << endl;
return 0;
}
// This code is contributed by aishwarya.27 |
// Java implementation of the approach class GFG {
// Function to return the count of all identical rows
public static int countIdenticalRows( int mat[][])
{
int count = 0 ;
for ( int i = 0 ; i < mat.length; i++) {
// First element of current row
int first = mat[i][ 0 ];
boolean allSame = true ;
// Compare every element of the current row
// with the first element of the row
for ( int j = 1 ; j < mat[i].length; j++) {
// If any element is different
if (mat[i][j] != first) {
allSame = false ;
break ;
}
}
// If all the elements of the
// current row were same
if (allSame)
count++;
}
return count;
}
// Driver code
public static void main(String[] args)
{
int mat[][] = { { 1 , 1 , 2 },
{ 2 , 2 , 2 },
{ 5 , 5 , 2 } };
System.out.print(countIdenticalRows(mat));
}
} |
# Python 3 implementation of the approach # Function to return the count of # all identical rows def countIdenticalRows(mat):
count = 0
for i in range ( len (mat)):
# First element of current row
first = mat[i][ 0 ]
allSame = True
# Compare every element of the current
# row with the first element of the row
for j in range ( 1 , len (mat[i])):
# If any element is different
if (mat[i][j] ! = first):
allSame = False
break
# If all the elements of the
# current row were same
if (allSame):
count + = 1
return count
# Driver code if __name__ = = "__main__" :
mat = [[ 1 , 1 , 2 ],
[ 2 , 2 , 2 ],
[ 5 , 5 , 2 ]]
print (countIdenticalRows(mat))
# This code is contributed by ita_c |
// C# implementation of the approach using System;
class GFG {
// Function to return the count of all identical rows
public static int countIdenticalRows( int [,]mat)
{
int count = 0;
for ( int i = 0; i < mat.GetLength(0); i++) {
// First element of current row
int first = mat[i,0];
bool allSame = true ;
// Compare every element of the current row
// with the first element of the row
for ( int j = 1; j < mat.GetLength(1); j++) {
// If any element is different
if (mat[i,j] != first) {
allSame = false ;
break ;
}
}
// If all the elements of the
// current row were same
if (allSame)
count++;
}
return count;
}
// Driver code
public static void Main()
{
int [,]mat = { { 1, 1, 2 },
{ 2, 2, 2 },
{ 5, 5, 2 } };
Console.Write(countIdenticalRows(mat));
}
// This code is contributed by Ryuga
} |
<?php // PHP implementation of the approach // Function to return the count of // all identical rows function countIdenticalRows(& $mat )
{ $count = 0;
for ( $i = 0; $i < sizeof( $mat ); $i ++)
{
// First element of current row
$first = $mat [ $i ][0];
$allSame = true;
// Compare every element of the current
// row with the first element of the row
for ( $j = 1; $j < sizeof( $mat [ $i ]); $j ++)
{
// If any element is different
if ( $mat [ $i ][ $j ] != $first )
{
$allSame = false;
break ;
}
}
// If all the elements of the
// current row were same
if ( $allSame )
$count ++;
}
return $count ;
} // Driver code $mat = array ( array (1, 1, 2),
array (2, 2, 2),
array (5, 5, 2));
echo (countIdenticalRows( $mat ));
// This code is contributed by Shivi_Aggarwal ?> |
<script> // Javascript implementation of the approach // Function to return the count of all identical rows function countIdenticalRows(mat)
{ let count = 0;
for (let i = 0; i < mat.length; i++) {
// First element of current row
let first = mat[i][0];
let allSame = true ;
// Compare every element of the current row
// with the first element of the row
for (let j = 1; j < mat[i].length; j++) {
// If any element is different
if (mat[i][j] != first) {
allSame = false ;
break ;
}
}
// If all the elements of the
// current row were same
if (allSame)
count++;
}
return count;
} // Driver code let mat = [[ 1, 1, 2 ], [2, 2, 2 ],
[5, 5, 2 ]];
document.write(countIdenticalRows(mat)); // This code is contributed by rag2127 </script> |
1
Complexity Analysis:
- Time Complexity: O(N*M), as we are using nested loops for traversing N*M times. Where N and M are the number of rows and columns respectively.
- Auxiliary Space: O(1), as we are not using any extra space.