# Count all sorted rows in a matrix

Given a matrix of integer elements, whose is each row include more than one element. Our goal is to find all sorted rows in this matrix. Whose row element is sorted of left to right or right to left direction. In other words count the row which is sorted in ascending and descending order.

Note that arrow in above image indicates direction of sorted row. Here given code implementation process.

``````/*
Java Program
Count all sorted rows in a matrix
*/
public class Test
{
// Display element of matrix
public void showData(int[][] matrix)
{
int row = matrix.length;
int col = matrix[0].length;
// This loop is iterating rows
for (int i = 0; i < row; ++i)
{
// This loop is iterating cols
for (int j = 0; j < col; ++j)
{
System.out.print("  " + matrix[i][j]);
}
System.out.print("\n");
}
System.out.print("\n");
}
// Count sorted rows in given matrix
public void sortedRows(int[][] matrix)
{
// Get size
int row = matrix.length;
int col = matrix[0].length;
// Resulant counter
int result = 0;
// This loop is iterating rows
for (int i = 0; i < row; ++i)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
boolean flag = matrix[i][0] > matrix[i][col - 1];
// Assume that is  a sorted row
result++;
// Check if row is sorted or not
for (int j = 1; j < col; ++j)
{
if (flag == true && matrix[i][j - 1] < matrix[i][j])
{
// is not sorted
result--;
break;
}
else if (flag == false && matrix[i][j - 1] > matrix[i][j])
{
// is not sorted
result--;
break;
}
}
}
// Display calculated result
System.out.println(" Sorted Rows : " + result);
}
public static void main(String[] args)
{
// Matrix of integer elements
int[][] matrix = {
{1 , 2 , 3 , 4 , 5 , 6},
{4 , 8 , 7 , 8 , 5 , 1},
{9 , 8 , 7 , 7 , 5 , 1},
{7 , 7 , 6 , 5 , 4 , 1},
{7 , 3 , 2 , 5 , 1 , 1},
{5 , 5 , 5 , 5 , 5 , 5}
};
}
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````// Include header file
#include <iostream>
#include <vector>
using namespace std;
/*
C++ Program
Count all sorted rows in a matrix
*/
class Test
{
public:
// Display element of matrix
void showData(vector<vector<int>> matrix)
{
// Get size
int row = matrix.size();
int col = matrix[0].size();
// This loop is iterating rows
for (int i = 0; i < row; ++i)
{
// This loop is iterating cols
for (int j = 0; j < col; ++j)
{
cout << "  " << matrix[i][j];
}
cout << "\n";
}
cout << "\n";
}
// Count sorted rows in given matrix
void sortedRows(vector<vector<int>> matrix)
{
// Get size
int row = matrix.size();
int col = matrix[0].size();
// Resulant counter
int result = 0;
// This loop is iterating rows
for (int i = 0; i < row; ++i)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
bool flag = matrix[i][0] > matrix[i][col - 1];
// Assume that is  a sorted row
result++;
// Check if row is sorted or not
for (int j = 1; j < col; ++j)
{
if (flag == true && matrix[i][j - 1] < matrix[i][j])
{
// is not sorted
result--;
break;
}
else if (flag == false && matrix[i][j - 1] > matrix[i][j])
{
// is not sorted
result--;
break;
}
}
}
// Display calculated result
cout << " Sorted Rows : " << result << endl;
}
};
int main()
{
// Matrix of integer elements
vector<vector<int>> matrix {
{1 , 2 , 3 , 4 , 5 , 6},
{4 , 8 , 7 , 8 , 5 , 1},
{9 , 8 , 7 , 7 , 5 , 1},
{7 , 7 , 6 , 5 , 4 , 1},
{7 , 3 , 2 , 5 , 1 , 1},
{5 , 5 , 5 , 5 , 5 , 5}
};
return 0;
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````/*
C Program
+ Count all sorted rows in a matrix
*/
#include <stdio.h>
#define ROW 6
#define COL 6

// Display element of matrix
void show_data(int matrix[][COL])
{
for (int i = 0; i < ROW; ++i)
{
for (int j = 0; j < COL; ++j)
{
printf("%3d", matrix[i][j]);
}
printf("\n");
}
printf("\n");
}

// Count sorted rows in given matrix
void sorted_rows(int matrix[ROW][COL])
{
int flag = 0;
int counter = 0;

// This loop is iterating rows
for (int i = 0; i < ROW; ++i)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
flag = matrix[i][0] > matrix[i][COL - 1];

// Assume that is  a sorted row
counter++;

// Check if row is sorted or not
for (int j = 1; j < COL; ++j)
{
if (flag == 1 && matrix[i][j - 1] < matrix[i][j])
{
// is not sorted
counter--;
break;
}
else if (flag == 0 && matrix[i][j - 1] > matrix[i][j])
{
// is not sorted
counter--;
break;
}
}
}
// Display calculated result
printf("  Sorted Rows : %d\n", counter);
}
int main()
{
int matrix[ROW][COL] =
{
{1 , 2 , 3 , 4 , 5 , 6},
{4 , 8 , 7 , 8 , 5 , 1},
{9 , 8 , 7 , 7 , 5 , 1},
{7 , 7 , 6 , 5 , 4 , 1},
{7 , 3 , 2 , 5 , 1 , 1},
{5 , 5 , 5 , 5 , 5 , 5},

};
// Display matrix
show_data(matrix);

// count sorted row
sorted_rows(matrix);
return 0;
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````package main
import "fmt"
/*
Go Program
Count all sorted rows in a matrix
*/
type Test struct {}
func getTest() * Test {
var me *Test = &Test {}
return me
}
// Display element of matrix
func(this Test) showData(matrix[][] int) {
var row int = len(matrix)
var col int = len(matrix[0])
// This loop is iterating rows
for i := 0 ; i < row ; i++ {
// This loop is iterating cols
for j := 0 ; j < col ; j++ {
fmt.Print("  ", matrix[i][j])
}
fmt.Print("\n")
}
fmt.Print("\n")
}
// Count sorted rows in given matrix
func(this Test) sortedRows(matrix[][] int) {
// Get size
var row int = len(matrix)
var col int = len(matrix[0])
// Resulant counter
var result int = 0
// This loop is iterating rows
for i := 0 ; i < row ; i++ {
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
var flag bool = matrix[i][0] > matrix[i][col - 1]
// Assume that is  a sorted row
result++
// Check if row is sorted or not
for j := 1 ; j < col ; j++ {
if flag == true && matrix[i][j - 1] < matrix[i][j] {
// is not sorted
result--
break
} else if flag == false && matrix[i][j - 1] > matrix[i][j] {
// is not sorted
result--
break
}
}
}
// Display calculated result
fmt.Println(" Sorted Rows : ", result)
}
func main() {
var task * Test = getTest()
// Matrix of integer elements
var matrix = [][] int {
{1 , 2 , 3 , 4 , 5 , 6},
{4 , 8 , 7 , 8 , 5 , 1},
{9 , 8 , 7 , 7 , 5 , 1},
{7 , 7 , 6 , 5 , 4 , 1},
{7 , 3 , 2 , 5 , 1 , 1},
{5 , 5 , 5 , 5 , 5 , 5},
}
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````// Include namespace system
using System;
/*
Csharp Program
Count all sorted rows in a matrix
*/
public class Test
{
// Display element of matrix
public void showData(int[,] matrix)
{
int row = matrix.GetLength(0);
int col = matrix.GetLength(1);
// This loop is iterating rows
for (int i = 0; i < row; ++i)
{
// This loop is iterating cols
for (int j = 0; j < col; ++j)
{
Console.Write("  " + matrix[i,j]);
}
Console.Write("\n");
}
Console.Write("\n");
}
// Count sorted rows in given matrix
public void sortedRows(int[,] matrix)
{
// Get size
int row = matrix.GetLength(0);
int col = matrix.GetLength(1);
// Resulant counter
int result = 0;
// This loop is iterating rows
for (int i = 0; i < row; ++i)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
Boolean flag = matrix[i,0] > matrix[i,col - 1];
// Assume that is  a sorted row
result++;
// Check if row is sorted or not
for (int j = 1; j < col; ++j)
{
if (flag == true && matrix[i,j - 1] < matrix[i,j])
{
// is not sorted
result--;
break;
}
else if (flag == false && matrix[i,j - 1] > matrix[i,j])
{
// is not sorted
result--;
break;
}
}
}
// Display calculated result
Console.WriteLine(" Sorted Rows : " + result);
}
public static void Main(String[] args)
{
// Matrix of integer elements
int[,] matrix = {
{1 , 2 , 3 , 4 , 5 , 6},
{4 , 8 , 7 , 8 , 5 , 1},
{9 , 8 , 7 , 7 , 5 , 1},
{7 , 7 , 6 , 5 , 4 , 1},
{7 , 3 , 2 , 5 , 1 , 1},
{5 , 5 , 5 , 5 , 5 , 5}
};
}
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````<?php
/*
Php Program
Count all sorted rows in a matrix
*/
class Test
{
// Display element of matrix
public  function showData(\$matrix)
{
\$row = count(\$matrix);
\$col = count(\$matrix[0]);
// This loop is iterating rows
for (\$i = 0; \$i < \$row; ++\$i)
{
// This loop is iterating cols
for (\$j = 0; \$j < \$col; ++\$j)
{
echo("  ".\$matrix[\$i][\$j]);
}
echo("\n");
}
echo("\n");
}
// Count sorted rows in given matrix
public  function sortedRows(\$matrix)
{
// Get size
\$row = count(\$matrix);
\$col = count(\$matrix[0]);
// Resulant counter
\$result = 0;
// This loop is iterating rows
for (\$i = 0; \$i < \$row; ++\$i)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
\$flag = \$matrix[\$i][0] > \$matrix[\$i][\$col - 1];
// Assume that is  a sorted row
\$result++;
// Check if row is sorted or not
for (\$j = 1; \$j < \$col; ++\$j)
{
if (\$flag == true &&
\$matrix[\$i][\$j - 1] < \$matrix[\$i][\$j])
{
// is not sorted
\$result--;
break;
}
else if (\$flag == false &&
\$matrix[\$i][\$j - 1] > \$matrix[\$i][\$j])
{
// is not sorted
\$result--;
break;
}
}
}
// Display calculated result
echo(" Sorted Rows : ".\$result."\n");
}
}

function main()
{
// Matrix of integer elements
\$matrix = array(
array(1, 2, 3, 4, 5, 6),
array(4, 8, 7, 8, 5, 1),
array(9, 8, 7, 7, 5, 1),
array(7, 7, 6, 5, 4, 1),
array(7, 3, 2, 5, 1, 1),
array(5, 5, 5, 5, 5, 5)
);
}
main();``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````/*
Node JS Program
Count all sorted rows in a matrix
*/
class Test
{
// Display element of matrix
showData(matrix)
{
var row = matrix.length;
var col = matrix[0].length;
// This loop is iterating rows
for (var i = 0; i < row; ++i)
{
// This loop is iterating cols
for (var j = 0; j < col; ++j)
{
process.stdout.write("  " + matrix[i][j]);
}
process.stdout.write("\n");
}
process.stdout.write("\n");
}
// Count sorted rows in given matrix
sortedRows(matrix)
{
// Get size
var row = matrix.length;
var col = matrix[0].length;
// Resulant counter
var result = 0;
// This loop is iterating rows
for (var i = 0; i < row; ++i)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
var flag = matrix[i][0] > matrix[i][col - 1];
// Assume that is  a sorted row
result++;
// Check if row is sorted or not
for (var j = 1; j < col; ++j)
{
if (flag == true &&
matrix[i][j - 1] < matrix[i][j])
{
// is not sorted
result--;
break;
}
else if (flag == false &&
matrix[i][j - 1] > matrix[i][j])
{
// is not sorted
result--;
break;
}
}
}
// Display calculated result
console.log(" Sorted Rows : " + result);
}
}

function main()
{
// Matrix of integer elements
var matrix = [
[1, 2, 3, 4, 5, 6],
[4, 8, 7, 8, 5, 1],
[9, 8, 7, 7, 5, 1],
[7, 7, 6, 5, 4, 1],
[7, 3, 2, 5, 1, 1],
[5, 5, 5, 5, 5, 5]
];
}
main();``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````#  Python 3 Program
#  Count all sorted rows in a matrix
class Test :
#  Display element of matrix
def showData(self, matrix) :
row = len(matrix)
col = len(matrix[0])
i = 0
#  This loop is iterating rows
while (i < row) :
j = 0
#  This loop is iterating cols
while (j < col) :
print("  ", matrix[i][j], end = "")
j += 1

print(end = "\n")
i += 1

print(end = "\n")

#  Count sorted rows in given matrix
def sortedRows(self, matrix) :
#  Get size
row = len(matrix)
col = len(matrix[0])
#  Resulant counter
result = 0
i = 0
#  This loop is iterating rows
while (i < row) :
#  If flag equal to 1 then work on decreasing order
#  Otherwise work on increasing order
#  Check first and last element of i row
flag = matrix[i][0] > matrix[i][col - 1]
#  Assume that is  a sorted row
result += 1
j = 1
#  Check if row is sorted or not
while (j < col) :
if (flag == True and matrix[i][j - 1] < matrix[i][j]) :
#  is not sorted
result -= 1
break
elif (flag == False and matrix[i][j - 1] > matrix[i][j]) :
#  is not sorted
result -= 1
break

j += 1

i += 1

#  Display calculated result
print(" Sorted Rows : ", result)

def main() :
#  Matrix of integer elements
matrix = [
[1, 2, 3, 4, 5, 6],
[4, 8, 7, 8, 5, 1],
[9, 8, 7, 7, 5, 1],
[7, 7, 6, 5, 4, 1],
[7, 3, 2, 5, 1, 1],
[5, 5, 5, 5, 5, 5]
]

if __name__ == "__main__": main()``````

#### Output

``````   1   2   3   4   5   6
4   8   7   8   5   1
9   8   7   7   5   1
7   7   6   5   4   1
7   3   2   5   1   1
5   5   5   5   5   5

Sorted Rows :  4``````
``````#  Ruby Program
#  Count all sorted rows in a matrix
class Test
#  Display element of matrix
def showData(matrix)
row = matrix.length
col = matrix[0].length
i = 0
#  This loop is iterating rows
while (i < row)
j = 0
#  This loop is iterating cols
while (j < col)
print("  ", matrix[i][j])
j += 1
end

print("\n")
i += 1
end

print("\n")
end

#  Count sorted rows in given matrix
def sortedRows(matrix)
#  Get size
row = matrix.length
col = matrix[0].length
#  Resulant counter
result = 0
i = 0
#  This loop is iterating rows
while (i < row)
#  If flag equal to 1 then work on decreasing order
#  Otherwise work on increasing order
#  Check first and last element of i row
flag = matrix[i][0] > matrix[i][col - 1]
#  Assume that is  a sorted row
result += 1
j = 1
#  Check if row is sorted or not
while (j < col)
if (flag == true && matrix[i][j - 1] < matrix[i][j])
#  is not sorted
result -= 1
break
elsif (flag == false && matrix[i][j - 1] > matrix[i][j])
#  is not sorted
result -= 1
break
end

j += 1
end

i += 1
end

#  Display calculated result
print(" Sorted Rows : ", result, "\n")
end

end

def main()
#  Matrix of integer elements
matrix = [
[1, 2, 3, 4, 5, 6],
[4, 8, 7, 8, 5, 1],
[9, 8, 7, 7, 5, 1],
[7, 7, 6, 5, 4, 1],
[7, 3, 2, 5, 1, 1],
[5, 5, 5, 5, 5, 5]
]
end

main()``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4
``````
``````/*
Scala Program
Count all sorted rows in a matrix
*/
import scala.util.control._
class Test()
{
// Display element of matrix
def showData(matrix: Array[Array[Int]]): Unit = {
var row: Int = matrix.length;
var col: Int = matrix(0).length;
var i: Int = 0;
// This loop is iterating rows
while (i < row)
{
var j: Int = 0;
// This loop is iterating cols
while (j < col)
{
print("  " + matrix(i)(j));
j += 1;
}
print("\n");
i += 1;
}
print("\n");
}
// Count sorted rows in given matrix
def sortedRows(matrix: Array[Array[Int]]): Unit = {
// Get size
var row: Int = matrix.length;
var col: Int = matrix(0).length;
// Resulant counter
var result: Int = 0;
var i: Int = 0;
val breakLoop = new Breaks;
// This loop is iterating rows
while (i < row)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
var flag: Boolean = matrix(i)(0) > matrix(i)(col - 1);
// Assume that is  a sorted row
result += 1;
var j: Int = 1;
breakLoop.breakable
{
// Check if row is sorted or not
while (j < col)
{
if (flag == true && matrix(i)(j - 1) < matrix(i)(j))
{
// is not sorted
result -= 1;
breakLoop.break;
}
else if (flag == false && matrix(i)(j - 1) > matrix(i)(j))
{
// is not sorted
result -= 1;
breakLoop.break;
}
j += 1;
}
}
i += 1;
}
// Display calculated result
println(" Sorted Rows : " + result);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Test = new Test();
// Matrix of integer elements
var matrix: Array[Array[Int]] = Array(
Array(1, 2, 3, 4, 5, 6),
Array(4, 8, 7, 8, 5, 1),
Array(9, 8, 7, 7, 5, 1),
Array(7, 7, 6, 5, 4, 1),
Array(7, 3, 2, 5, 1, 1),
Array(5, 5, 5, 5, 5, 5)
);
}
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````
``````import Foundation;
/*
Swift 4 Program
Count all sorted rows in a matrix
*/
class Test
{
// Display element of matrix
func showData(_ matrix: [[Int]])
{
let row: Int = matrix.count;
let col: Int = matrix[0].count;
var i: Int = 0;
// This loop is iterating rows
while (i < row)
{
var j: Int = 0;
// This loop is iterating cols
while (j < col)
{
print("  ", matrix[i][j], terminator: "");
j += 1;
}
print(terminator: "\n");
i += 1;
}
print(terminator: "\n");
}
// Count sorted rows in given matrix
func sortedRows(_ matrix: [
[Int]
])
{
// Get size
let row: Int = matrix.count;
let col: Int = matrix[0].count;
// Resulant counter
var result: Int = 0;
var i: Int = 0;
// This loop is iterating rows
while (i < row)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
let flag: Bool = matrix[i][0] > matrix[i][col - 1];
// Assume that is  a sorted row
result += 1;
var j: Int = 1;
// Check if row is sorted or not
while (j < col)
{
if (flag == true && matrix[i][j - 1] < matrix[i][j])
{
// is not sorted
result -= 1;
break;
}
else if (flag == false && matrix[i][j - 1] > matrix[i][j])
{
// is not sorted
result -= 1;
break;
}
j += 1;
}
i += 1;
}
// Display calculated result
print(" Sorted Rows : ", result);
}
}
func main()
{
// Matrix of integer elements
let matrix: [
[Int]
] = [
[1, 2, 3, 4, 5, 6],
[4, 8, 7, 8, 5, 1],
[9, 8, 7, 7, 5, 1],
[7, 7, 6, 5, 4, 1],
[7, 3, 2, 5, 1, 1],
[5, 5, 5, 5, 5, 5]
];
}
main();``````

#### Output

``````   1   2   3   4   5   6
4   8   7   8   5   1
9   8   7   7   5   1
7   7   6   5   4   1
7   3   2   5   1   1
5   5   5   5   5   5

Sorted Rows :  4``````
``````/*
Kotlin Program
Count all sorted rows in a matrix
*/
class Test
{
// Display element of matrix
fun showData(matrix: Array < Array < Int >> ): Unit
{
val row: Int = matrix.count();
val col: Int = matrix[0].count();
var i: Int = 0;
// This loop is iterating rows
while (i < row)
{
var j: Int = 0;
// This loop is iterating cols
while (j < col)
{
print("  " + matrix[i][j]);
j += 1;
}
print("\n");
i += 1;
}
print("\n");
}
// Count sorted rows in given matrix
fun sortedRows(matrix: Array < Array < Int >> ): Unit
{
// Get size
val row: Int = matrix.count();
val col: Int = matrix[0].count();
// Resulant counter
var result: Int = 0;
var i: Int = 0;
// This loop is iterating rows
while (i < row)
{
// If flag equal to 1 then work on decreasing order
// Otherwise work on increasing order
// Check first and last element of i row
val flag: Boolean = matrix[i][0] > matrix[i][col - 1];
// Assume that is  a sorted row
result += 1;
var j: Int = 1;
// Check if row is sorted or not
while (j < col)
{
if (flag == true && matrix[i][j - 1] < matrix[i][j])
{
// is not sorted
result -= 1;
break;
}
else if (flag == false && matrix[i][j - 1] > matrix[i][j])
{
// is not sorted
result -= 1;
break;
}
j += 1;
}
i += 1;
}
// Display calculated result
println(" Sorted Rows : " + result);
}
}
fun main(args: Array < String > ): Unit
{
// Matrix of integer elements
val matrix: Array < Array < Int >> = arrayOf(
arrayOf(1, 2, 3, 4, 5, 6),
arrayOf(4, 8, 7, 8, 5, 1),
arrayOf(9, 8, 7, 7, 5, 1),
arrayOf(7, 7, 6, 5, 4, 1),
arrayOf(7, 3, 2, 5, 1, 1),
arrayOf(5, 5, 5, 5, 5, 5)
);
}``````

#### Output

``````  1  2  3  4  5  6
4  8  7  8  5  1
9  8  7  7  5  1
7  7  6  5  4  1
7  3  2  5  1  1
5  5  5  5  5  5

Sorted Rows : 4``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.