Skip to content
Related Articles

Related Articles

Count rows in a matrix that consist of same element
  • Difficulty Level : Hard
  • Last Updated : 01 Aug, 2019

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 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 count.



Below is the implementation of the above approach:

C++




// 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




// 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));
    }
}

Python3




#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#




// 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
Output:
2

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++




// 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




// 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




# 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#




// 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
// 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
?>
Output:
1
My Personal Notes arrow_drop_up
Recommended Articles
Page :