# Count rows in a matrix that consist of same element

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++ implementation of the approach  ` `#include ` ` `  `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 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 `

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++ implementation of the approach ` `#include ` ` `  `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 ` `}  `

 ` `

Output:
```1
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Article Tags :
Practice Tags :