Given a matrix of m*n size, the task is to count all the rows in a matrix that are sorted either in strictly increasing order or in strictly decreasing order?
Examples :
Input : m = 4, n = 5 mat[m][n] = 1 2 3 4 5 4 3 1 2 6 8 7 6 5 4 5 7 8 9 10 Output: 3
The idea is simple and involves two traversals of matrix.
- Traverse from left side of the matrix to count all the row which are in strictly increasing order
- Traverse from right side of the matrix to count all the row which are in strictly decreasing order
Below is the implementation of above idea.
C++
// C++ program to find number of sorted rows #include <bits/stdc++.h> #define MAX 100 using namespace std;
// Function to count all sorted rows in a matrix int sortedCount( int mat[][MAX], int r, int c)
{ int result = 0; // Initialize result
// Start from left side of matrix to
// count increasing order rows
for ( int i=0; i<r; i++)
{
// Check if there is any pair of element
// that are not in increasing order.
int j;
for (j=0; j<c-1; j++)
if (mat[i][j+1] <= mat[i][j])
break ;
// If the loop didn't break (All elements
// of current row were in increasing order)
if (j == c-1)
result++;
}
// Start from right side of matrix to
// count increasing order rows ( reference
// to left these are in decreasing order )
for ( int i=0; i<r; i++)
{
// Check if there is any pair of element
// that are not in decreasing order.
int j;
for (j=c-1; j>0; j--)
if (mat[i][j-1] <= mat[i][j])
break ;
// Note c > 1 condition is required to make
// sure that a single column row is not counted
// twice (Note that a single column row is sorted
// both in increasing and decreasing order)
if (c > 1 && j == 0)
result++;
}
return result;
} // Driver program to run the case int main()
{ int m = 4, n = 5;
int mat[][MAX] = {{1, 2, 3, 4, 5},
{4, 3, 1, 2, 6},
{8, 7, 6, 5, 4},
{5, 7, 8, 9, 10}};
cout << sortedCount(mat, m, n);
return 0;
} |
Java
// Java program to find number of sorted rows class GFG {
static int MAX = 100 ;
// Function to count all sorted rows in a matrix
static int sortedCount( int mat[][], int r, int c)
{
int result = 0 ; // Initialize result
// Start from left side of matrix to
// count increasing order rows
for ( int i = 0 ; i < r; i++) {
// Check if there is any pair of element
// that are not in increasing order.
int j;
for (j = 0 ; j < c - 1 ; j++)
if (mat[i][j + 1 ] <= mat[i][j])
break ;
// If the loop didn't break (All elements
// of current row were in increasing order)
if (j == c - 1 )
result++;
}
// Start from right side of matrix to
// count increasing order rows ( reference
// to left these are in decreasing order )
for ( int i = 0 ; i < r; i++) {
// Check if there is any pair of element
// that are not in decreasing order.
int j;
for (j = c - 1 ; j > 0 ; j--)
if (mat[i][j - 1 ] <= mat[i][j])
break ;
// Note c > 1 condition is required to make
// sure that a single column row is not counted
// twice (Note that a single column row is sorted
// both in increasing and decreasing order)
if (c > 1 && j == 0 )
result++;
}
return result;
}
// Driver code
public static void main(String arg[])
{
int m = 4 , n = 5 ;
int mat[][] = { { 1 , 2 , 3 , 4 , 5 },
{ 4 , 3 , 1 , 2 , 6 },
{ 8 , 7 , 6 , 5 , 4 },
{ 5 , 7 , 8 , 9 , 10 } };
System.out.print(sortedCount(mat, m, n));
}
} // This code is contributed by Anant Agarwal. |
Python
# Python3 program to find number # of sorted rows def sortedCount(mat, r, c):
result = 0
# Start from left side of matrix to
# count increasing order rows
for i in range (r):
# Check if there is any pair of element
# that are not in increasing order.
j = 0
for j in range (c - 1 ):
if mat[i][j + 1 ] < = mat[i][j]:
break
# If the loop didn't break (All elements
# of current row were in increasing order)
if j = = c - 2 :
result + = 1
# Start from right side of matrix to
# count increasing order rows ( reference
# to left these are in decreasing order )
for i in range ( 0 , r):
# Check if there is any pair of element
# that are not in decreasing order.
j = 0
for j in range (c - 1 , 0 , - 1 ):
if mat[i][j - 1 ] < = mat[i][j]:
break
# Note c > 1 condition is required to
# make sure that a single column row
# is not counted twice (Note that a
# single column row is sorted both
# in increasing and decreasing order)
if c > 1 and j = = 1 :
result + = 1
return result
# Driver code m, n = 4 , 5
mat = [[ 1 , 2 , 3 , 4 , 5 ],
[ 4 , 3 , 1 , 2 , 6 ],
[ 8 , 7 , 6 , 5 , 4 ],
[ 5 , 7 , 8 , 9 , 10 ]]
print (sortedCount(mat, m, n))
# This code is contributed by # Mohit kumar 29 (IIIT gwalior) |
C#
// C# program to find number of sorted rows using System;
class GFG {
// static int MAX = 100; // Function to count all sorted rows in
// a matrix
static int sortedCount( int [,]mat, int r,
int c)
{
int result = 0; // Initialize result
// Start from left side of matrix to
// count increasing order rows
for ( int i = 0; i < r; i++) {
// Check if there is any pair of
// element that are not in
// increasing order.
int j;
for (j = 0; j < c - 1; j++)
if (mat[i,j + 1] <= mat[i,j])
break ;
// If the loop didn't break (All
// elements of current row were
// in increasing order)
if (j == c - 1)
result++;
}
// Start from right side of matrix
// to count increasing order rows
// ( reference to left these are in
// decreasing order )
for ( int i = 0; i < r; i++) {
// Check if there is any pair
// of element that are not in
// decreasing order.
int j;
for (j = c - 1; j > 0; j--)
if (mat[i,j - 1] <= mat[i,j])
break ;
// Note c > 1 condition is
// required to make sure that a
// single column row is not
// counted twice (Note that a
// single column row is sorted
// both in increasing and
// decreasing order)
if (c > 1 && j == 0)
result++;
}
return result;
}
// Driver code
public static void Main()
{
int m = 4, n = 5;
int [,]mat = { { 1, 2, 3, 4, 5 },
{ 4, 3, 1, 2, 6 },
{ 8, 7, 6, 5, 4 },
{ 5, 7, 8, 9, 10 } };
Console.WriteLine(
sortedCount(mat, m, n));
}
} // This code is contributed by anuj_67. |
PHP
<?php // PHP program to find // number of sorted rows $MAX = 100;
// Function to count all // sorted rows in a matrix function sortedCount( $mat ,
$r , $c )
{ // Initialize result
$result = 0;
// Start from left side of
// matrix to count increasing
// order rows
for ( $i = 0; $i < $r ; $i ++)
{
// Check if there is any
// pair of element that
// are not in increasing order.
$j ;
for ( $j = 0; $j < $c - 1; $j ++)
if ( $mat [ $i ][ $j + 1] <= $mat [ $i ][ $j ])
break ;
// If the loop didn't break
// (All elements of current
// row were in increasing order)
if ( $j == $c - 1)
$result ++;
}
// Start from right side of
// matrix to count increasing
// order rows ( reference to left
// these are in decreasing order )
for ( $i = 0; $i < $r ; $i ++)
{
// Check if there is any pair
// of element that are not
// in decreasing order.
$j ;
for ( $j = $c - 1; $j > 0; $j --)
if ( $mat [ $i ][ $j - 1] <= $mat [ $i ][ $j ])
break ;
// Note c > 1 condition is
// required to make sure that
// a single column row is not
// counted twice (Note that a
// single column row is sorted
// both in increasing and
// decreasing order)
if ( $c > 1 && $j == 0)
$result ++;
}
return $result ;
} // Driver Code $m = 4; $n = 5;
$mat = array ( array (1, 2, 3, 4, 5),
array (4, 3, 1, 2, 6),
array (8, 7, 6, 5, 4),
array (5, 7, 8, 9, 10));
echo sortedCount( $mat , $m , $n );
// This code is contributed by anuj_67. ?> |
Javascript
<script> // Javascript program to find number of sorted rows let MAX = 100;
// Function to count all sorted rows in a matrix
function sortedCount(mat,r,c)
{
let result = 0; // Initialize result
// Start from left side of matrix to
// count increasing order rows
for (let i = 0; i < r; i++) {
// Check if there is any pair of element
// that are not in increasing order.
let j;
for (j = 0; j < c - 1; j++)
if (mat[i][j + 1] <= mat[i][j])
break ;
// If the loop didn't break (All elements
// of current row were in increasing order)
if (j == c - 1)
result++;
}
// Start from right side of matrix to
// count increasing order rows ( reference
// to left these are in decreasing order )
for (let i = 0; i < r; i++) {
// Check if there is any pair of element
// that are not in decreasing order.
let j;
for (j = c - 1; j > 0; j--)
if (mat[i][j - 1] <= mat[i][j])
break ;
// Note c > 1 condition is required to make
// sure that a single column row is not counted
// twice (Note that a single column row is sorted
// both in increasing and decreasing order)
if (c > 1 && j == 0)
result++;
}
return result;
}
// Driver code
let m = 4, n = 5;
let mat = [[1, 2, 3, 4, 5],
[4, 3, 1, 2, 6],
[8, 7, 6, 5, 4],
[5, 7, 8, 9, 10]]
document.write(sortedCount(mat, m, n))
// This code is contributed by unknown2108
</script> |
Output
3
Time Complexity : O(m*n)
Auxiliary space : O(1)
If you have another optimized approach to solve this problem then please share in comments.
Recommended Articles