Count Negative Numbers in a Column-Wise and Row-Wise Sorted Matrix
Last Updated :
27 Mar, 2023
Find the number of negative numbers in a column-wise / row-wise sorted matrix M[][]. Suppose M has n rows and m columns.
Example:
Input: M = [-3, -2, -1, 1]
[-2, 2, 3, 4]
[4, 5, 7, 8]
Output : 4
We have 4 negative numbers in this matrix
We strongly recommend you to minimize your browser and try this yourself first.
Naive Solution:
Here's a naive, non-optimal solution.
We start from the top left corner and count the number of negative numbers one by one, from left to right and top to bottom.
With the given example:
[-3, -2, -1, 1]
[-2, 2, 3, 4]
[4, 5, 7, 8]
Evaluation process
[?, ?, ?, 1]
[?, 2, 3, 4]
[4, 5, 7, 8]
Below is the implementation of above idea:
C++
// CPP implementation of Naive method
// to count of negative numbers in
// M[n][m]
#include <bits/stdc++.h>
using namespace std;
int countNegative(int M[][4], int n, int m)
{
int count = 0;
// Follow the path shown using
// arrows above
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (M[i][j] < 0)
count += 1;
// no more negative numbers
// in this row
else
break;
}
}
return count;
}
// Driver program to test above functions
int main()
{
int M[3][4] = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
cout << countNegative(M, 3, 4);
return 0;
}
// This code is contributed by Niteesh Kumar
// Java implementation of Naive method
// to count of negative numbers in
// M[n][m]
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
static int countNegative(int M[][], int n,
int m)
{
int count = 0;
// Follow the path shown using
// arrows above
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (M[i][j] < 0)
count += 1;
// no more negative numbers
// in this row
else
break;
}
}
return count;
}
// Driver program to test above functions
public static void main(String[] args)
{
int M[][] = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
System.out.println(countNegative(M, 3, 4));
}
}
// This code is contributed by Chhavi
# Python implementation of Naive method to count of
# negative numbers in M[n][m]
def countNegative(M, n, m):
count = 0
# Follow the path shown using arrows above
for i in range(n):
for j in range(m):
if M[i][j] < 0:
count += 1
else:
# no more negative numbers in this row
break
return count
# Driver code
M = [
[-3, -2, -1, 1],
[-2, 2, 3, 4],
[ 4, 5, 7, 8]
]
print(countNegative(M, 3, 4))
// C# implementation of Naive method
// to count of negative numbers in
// M[n][m]
using System;
class GFG {
// Function to count
// negative number
static int countNegative(int[, ] M, int n,
int m)
{
int count = 0;
// Follow the path shown
// using arrows above
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (M[i, j] < 0)
count += 1;
// no more negative numbers
// in this row
else
break;
}
}
return count;
}
// Driver Code
public static void Main()
{
int[, ] M = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
Console.WriteLine(countNegative(M, 3, 4));
}
}
// This code is contributed by Sam007
<?php
// PHP implementation of Naive method
// to count of negative numbers in
// M[n][m]
function countNegative($M, $n, $m)
{
$count = 0;
// Follow the path shown using
// arrows above
for( $i = 0; $i < $n; $i++)
{
for( $j = 0; $j < $m; $j++)
{
if( $M[$i][$j] < 0 )
$count += 1;
// no more negative numbers
// in this row
else
break;
}
}
return $count;
}
// Driver Code
$M = array(array(-3, -2, -1, 1),
array(-2, 2, 3, 4),
array(4, 5, 7, 8));
echo countNegative($M, 3, 4);
// This code is contributed by anuj_67.
?>
<script>
// JavaScript implementation of Naive method
// to count of negative numbers in
// M[n][m]
function countNegative(M,n,m)
{
let count = 0;
// Follow the path shown using
// arrows above
for (let i = 0; i < n; i++) {
for (let j = 0; j < m; j++) {
if (M[i][j] < 0)
count += 1;
// no more negative numbers
// in this row
else
break;
}
}
return count;
}
// Driver program to test above functions
let M = [[ -3, -2, -1, 1 ],
[ -2, 2, 3, 4 ],
[ 4, 5, 7, 8 ]];
document.write(countNegative(M, 3, 4));
// This code is contributed by sravan kumar
</script>
Time Complexity: O(n*m), where n and m are the numbers of rows and columns of matrix M[][] respectively.
Auxiliary Space: O(1)
In this approach we are traversing through all the elements and therefore, in the worst case scenario (when all numbers are negative in the matrix), this takes O(n * m) time.
Optimal Solution:
Here's a more efficient solution:
- We start from the top right corner and find the position of the last negative number in the first row.
- Using this information, we find the position of the last negative number in the second row.
- We keep repeating this process until we either run out of negative numbers or we get to the last row.
With the given example:
[-3, -2, -1, 1]
[-2, 2, 3, 4]
[4, 5, 7, 8]
Here's the idea:
[-3, -2, ?, ?] -> Found 3 negative numbers in this row
[ ?, ?, ?, 4] -> Found 1 negative number in this row
[ ?, 5, 7, 8] -> No negative numbers in this row
Implementation:
C++
// CPP implementation of Efficient
// method to count of negative numbers
// in M[n][m]
#include <bits/stdc++.h>
using namespace std;
int countNegative(int M[][4], int n, int m)
{
// initialize result
int count = 0;
// Start with top right corner
int i = 0;
int j = m - 1;
// Follow the path shown using
// arrows above
while (j >= 0 && i < n) {
if (M[i][j] < 0) {
// j is the index of the
// last negative number
// in this row. So there
// must be ( j+1 )
count += j + 1;
// negative numbers in
// this row.
i += 1;
}
// move to the left and see
// if we can find a negative
// number there
else
j -= 1;
}
return count;
}
// Driver program to test above functions
int main()
{
int M[3][4] = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
cout << countNegative(M, 3, 4);
return 0;
}
// This code is contributed by Niteesh Kumar
// Java implementation of Efficient
// method to count of negative numbers
// in M[n][m]
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
static int countNegative(int M[][], int n,
int m)
{
// initialize result
int count = 0;
// Start with top right corner
int i = 0;
int j = m - 1;
// Follow the path shown using
// arrows above
while (j >= 0 && i < n) {
if (M[i][j] < 0) {
// j is the index of the
// last negative number
// in this row. So there
// must be ( j+1 )
count += j + 1;
// negative numbers in
// this row.
i += 1;
}
// move to the left and see
// if we can find a negative
// number there
else
j -= 1;
}
return count;
}
// Driver program to test above functions
public static void main(String[] args)
{
int M[][] = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
System.out.println(countNegative(M, 3, 4));
}
}
// This code is contributed by Chhavi
# Python implementation of Efficient method to count of
# negative numbers in M[n][m]
def countNegative(M, n, m):
count = 0 # initialize result
# Start with top right corner
i = 0
j = m - 1
# Follow the path shown using arrows above
while j >= 0 and i < n:
if M[i][j] < 0:
# j is the index of the last negative number
# in this row. So there must be ( j + 1 )
count += (j + 1)
# negative numbers in this row.
i += 1
else:
# move to the left and see if we can
# find a negative number there
j -= 1
return count
# Driver code
M = [
[-3, -2, -1, 1],
[-2, 2, 3, 4],
[4, 5, 7, 8]
]
print(countNegative(M, 3, 4))
// C# implementation of Efficient
// method to count of negative
// numbers in M[n][m]
using System;
class GFG {
// Function to count
// negative number
static int countNegative(int[, ] M, int n,
int m)
{
// initialize result
int count = 0;
// Start with top right corner
int i = 0;
int j = m - 1;
// Follow the path shown
// using arrows above
while (j >= 0 && i < n) {
if (M[i, j] < 0) {
// j is the index of the
// last negative number
// in this row. So there
// must be ( j + 1 )
count += j + 1;
// negative numbers in
// this row.
i += 1;
}
// move to the left and see
// if we can find a negative
// number there
else
j -= 1;
}
return count;
}
// Driver Code
public static void Main()
{
int[, ] M = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
Console.WriteLine(countNegative(M, 3, 4));
}
}
// This code is contributed by Sam007
<?php
// PHP implementation of Efficient
// method to count of negative numbers
// in M[n][m]
function countNegative( $M, $n, $m)
{
// initialize result
$count = 0;
// Start with top right corner
$i = 0;
$j = $m - 1;
// Follow the path shown using
// arrows above
while( $j >= 0 and $i < $n )
{
if( $M[$i][$j] < 0 )
{
// j is the index of the
// last negative number
// in this row. So there
// must be ( j+1 )
$count += $j + 1;
// negative numbers in
// this row.
$i += 1;
}
// move to the left and see
// if we can find a negative
// number there
else
$j -= 1;
}
return $count;
}
// Driver Code
$M = array(array(-3, -2, -1, 1),
array(-2, 2, 3, 4),
array(4, 5, 7, 8));
echo countNegative($M, 3, 4);
return 0;
// This code is contributed by anuj_67.
?>
<script>
// Javascript implementation of Efficient
// method to count of negative numbers
// in M[n][m]q
function countNegative(M, n, m)
{
// initialize result
let count = 0;
// Start with top right corner
let i = 0;
let j = m - 1;
// Follow the path shown using
// arrows above
while (j >= 0 && i < n)
{
if (M[i][j] < 0)
{
// j is the index of the
// last negative number
// in this row. So there
// must be ( j+1 )
count += j + 1;
// negative numbers in
// this row.
i += 1;
}
// move to the left and see
// if we can find a negative
// number there
else
j -= 1;
}
return count;
}
let M = [ [ -3, -2, -1, 1 ],
[ -2, 2, 3, 4 ],
[ 4, 5, 7, 8 ] ];
document.write(countNegative(M, 3, 4));
`
// This code is contributed by decode2207.
</script>
With this solution, we solve this problem still in O(n*m) time if no negative elements occur in the whole matrix. But when negative elements are present, less operations are needed to be performed to count negative numbers.
Time Complexity: O(n+m)
Auxiliary Space: O(1)
More Optimal Solution:
Here's a more efficient solution using binary search instead of linear search:
- We start from the first row and find the position of the last negative number in the first row using binary search.
- Using this information, we find the position of the last negative number in the second row by running binary search only until the position of the last negative number in the row above.
- We keep repeating this process until we either run out of negative numbers or we get to the last row.
With the given example:
[-3, -2, -1, 1]
[-2, 2, 3, 4]
[4, 5, 7, 8]
Here's the idea:
1. Count is initialized to 0
2. Binary search on full 1st row returns 2 as the index
of last negative integer, and we increase count to 0+(2+1) = 3.
3. For 2nd row, we run binary search from index 0 to index 2
and it returns 0 as the index of last negative integer.
We increase the count to 3+(0+1) = 4;
4. For 3rd row, first element is > 0, so we end the loop here.
C++
// C++ implementation of More efficient
// method to count number of negative numbers
// in row-column sorted matrix M[n][m]
#include<bits/stdc++.h>
using namespace std;
// Recursive binary search to get last negative
// value in a row between a start and an end
int getLastNegativeIndex(int array[], int start,
int end,int n)
{
// Base case
if (start == end)
{
return start;
}
// Get the mid for binary search
int mid = start + (end - start) / 2;
// If current element is negative
if (array[mid] < 0)
{
// If it is the rightmost negative
// element in the current row
if (mid + 1 < n && array[mid + 1] >= 0)
{
return mid;
}
// Check in the right half of the array
return getLastNegativeIndex(array,
mid + 1, end, n);
}
else
{
// Check in the left half of the array
return getLastNegativeIndex(array,
start, mid - 1, n);
}
}
// Function to return the count of
// negative numbers in the given matrix
int countNegative(int M[][4], int n, int m)
{
// Initialize result
int count = 0;
// To store the index of the rightmost negative
// element in the row under consideration
int nextEnd = m - 1;
// Iterate over all rows of the matrix
for (int i = 0; i < n; i++)
{
// If the first element of the current row
// is positive then there will be no negatives
// in the matrix below or after it
if (M[i][0] >= 0)
{
break;
}
// Run binary search only until the index of last
// negative Integer in the above row
nextEnd = getLastNegativeIndex(M[i], 0, nextEnd, 4);
count += nextEnd + 1;
}
return count;
}
// Driver code
int main()
{
int M[][4] = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
int r = 3;
int c = 4;
cout << (countNegative(M, r, c));
return 0;
}
// This code is contributed by Arnab Kundu
// Java implementation of More efficient
// method to count number of negative numbers
// in row-column sorted matrix M[n][m]
import java.util.*;
import java.lang.*;
import java.io.*;
class GFG {
// Recursive binary search to get last negative
// value in a row between a start and an end
static int getLastNegativeIndex(int array[], int start, int end)
{
// Base case
if (start == end) {
return start;
}
// Get the mid for binary search
int mid = start + (end - start) / 2;
// If current element is negative
if (array[mid] < 0) {
// If it is the rightmost negative
// element in the current row
if (mid + 1 < array.length && array[mid + 1] >= 0) {
return mid;
}
// Check in the right half of the array
return getLastNegativeIndex(array, mid + 1, end);
}
else {
// Check in the left half of the array
return getLastNegativeIndex(array, start, mid - 1);
}
}
// Function to return the count of
// negative numbers in the given matrix
static int countNegative(int M[][], int n, int m)
{
// Initialize result
int count = 0;
// To store the index of the rightmost negative
// element in the row under consideration
int nextEnd = m - 1;
// Iterate over all rows of the matrix
for (int i = 0; i < n; i++) {
// If the first element of the current row
// is positive then there will be no negatives
// in the matrix below or after it
if (M[i][0] >= 0) {
break;
}
// Run binary search only until the index of last
// negative Integer in the above row
nextEnd = getLastNegativeIndex(M[i], 0, nextEnd);
count += nextEnd + 1;
}
return count;
}
// Driver code
public static void main(String[] args)
{
int M[][] = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
int r = M.length;
int c = M[0].length;
System.out.println(countNegative(M, r, c));
}
}
// This code is contributed by Rahul Jain
# Python3 implementation of More efficient
# method to count number of negative numbers
# in row-column sorted matrix M[n][m]
# Recursive binary search to get last negative
# value in a row between a start and an end
def getLastNegativeIndex(array, start, end, n):
# Base case
if (start == end):
return start
# Get the mid for binary search
mid = start + (end - start) // 2
# If current element is negative
if (array[mid] < 0):
# If it is the rightmost negative
# element in the current row
if (mid + 1 < n and array[mid + 1] >= 0):
return mid
# Check in the right half of the array
return getLastNegativeIndex(array, mid + 1, end, n)
else:
# Check in the left half of the array
return getLastNegativeIndex(array, start, mid - 1, n)
# Function to return the count of
# negative numbers in the given matrix
def countNegative(M, n, m):
# Initialize result
count = 0
# To store the index of the rightmost negative
# element in the row under consideration
nextEnd = m - 1
# Iterate over all rows of the matrix
for i in range(n):
# If the first element of the current row
# is positive then there will be no negatives
# in the matrix below or after it
if (M[i][0] >= 0):
break
# Run binary search only until the index of last
# negative Integer in the above row
nextEnd = getLastNegativeIndex(M[i], 0, nextEnd, 4)
count += nextEnd + 1
return count
# Driver code
M = [[-3, -2, -1, 1],[-2, 2, 3, 4],[ 4, 5, 7, 8]]
r = 3
c = 4
print(countNegative(M, r, c))
# This code is contributed by shubhamsingh10
// C# implementation of More efficient
// method to count number of negative numbers
// in row-column sorted matrix M[n,m]
using System;
using System.Collections.Generic;
class GFG
{
// Recursive binary search to get last negative
// value in a row between a start and an end
static int getLastNegativeIndex(int []array, int start, int end)
{
// Base case
if (start == end)
{
return start;
}
// Get the mid for binary search
int mid = start + (end - start) / 2;
// If current element is negative
if (array[mid] < 0)
{
// If it is the rightmost negative
// element in the current row
if (mid + 1 < array.GetLength(0) && array[mid + 1] >= 0)
{
return mid;
}
// Check in the right half of the array
return getLastNegativeIndex(array, mid + 1, end);
}
else
{
// Check in the left half of the array
return getLastNegativeIndex(array, start, mid - 1);
}
}
// Function to return the count of
// negative numbers in the given matrix
static int countNegative(int [,]M, int n, int m)
{
// Initialize result
int count = 0;
// To store the index of the rightmost negative
// element in the row under consideration
int nextEnd = m - 1;
// Iterate over all rows of the matrix
for (int i = 0; i < n; i++)
{
// If the first element of the current row
// is positive then there will be no negatives
// in the matrix below or after it
if (M[i, 0] >= 0)
{
break;
}
// Run binary search only until the index of last
// negative int in the above row
nextEnd = getLastNegativeIndex(GetRow(M, i), 0, nextEnd);
count += nextEnd + 1;
}
return count;
}
public static int[] GetRow(int[,] matrix, int row)
{
var rowLength = matrix.GetLength(1);
var rowVector = new int[rowLength];
for (var i = 0; i < rowLength; i++)
rowVector[i] = matrix[row, i];
return rowVector;
}
// Driver code
public static void Main(String[] args)
{
int [,]M = { { -3, -2, -1, 1 },
{ -2, 2, 3, 4 },
{ 4, 5, 7, 8 } };
int r = M.GetLength(0);
int c = M.GetLength(1);
Console.WriteLine(countNegative(M, r, c));
}
}
// This code is contributed by PrinciRaj1992
<script>
// JavaScript implementation of More efficient
// method to count number of negative numbers
// in row-column sorted matrix M[n,m]
// Recursive binary search to get last negative
// value in a row between a start and an end
function getLastNegativeIndex(array, start, end)
{
// Base case
if (start == end)
{
return start;
}
// Get the mid for binary search
var mid = start + parseInt((end - start) / 2);
// If current element is negative
if (array[mid] < 0)
{
// If it is the rightmost negative
// element in the current row
if (mid + 1 < array.length && array[mid + 1] >= 0)
{
return mid;
}
// Check in the right half of the array
return getLastNegativeIndex(array, mid + 1, end);
}
else
{
// Check in the left half of the array
return getLastNegativeIndex(array, start, mid - 1);
}
}
// Function to return the count of
// negative numbers in the given matrix
function countNegative(M, n, m)
{
// Initialize result
var count = 0;
// To store the index of the rightmost negative
// element in the row under consideration
var nextEnd = m - 1;
// Iterate over all rows of the matrix
for (var i = 0; i < n; i++)
{
// If the first element of the current row
// is positive then there will be no negatives
// in the matrix below or after it
if (M[i][0] >= 0)
{
break;
}
// Run binary search only until the index of last
// negative int in the above row
nextEnd = getLastNegativeIndex(GetRow(M, i), 0, nextEnd);
count += nextEnd + 1;
}
return count;
}
function GetRow(matrix, row)
{
var rowLength = matrix[0].length;
var rowVector = Array(rowLength).fill(0);
for (var i = 0; i < rowLength; i++)
rowVector[i] = matrix[row][i];
return rowVector;
}
// Driver code
var M = [ [ -3, -2, -1, 1 ],
[ -2, 2, 3, 4 ],
[ 4, 5, 7, 8 ] ];
var r = M.length;
var c = M[0].length;
document.write(countNegative(M, r, c));
</script>
Here we have replaced the linear search for last negative number with a binary search. This should improve the worst case scenario keeping the Worst case to O(nlog(m)).
Similar Reads
Python Tutorial | Learn Python Programming Language Python Tutorial – Python is one of the most popular programming languages. It’s simple to use, packed with features and supported by a wide range of libraries and frameworks. Its clean syntax makes it beginner-friendly.Python is:A high-level language, used in web development, data science, automatio
10 min read
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Python Interview Questions and Answers Python is the most used language in top companies such as Intel, IBM, NASA, Pixar, Netflix, Facebook, JP Morgan Chase, Spotify and many more because of its simplicity and powerful libraries. To crack their Online Assessment and Interview Rounds as a Python developer, we need to master important Pyth
15+ min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Python OOPs Concepts Object Oriented Programming is a fundamental concept in Python, empowering developers to build modular, maintainable, and scalable applications. By understanding the core OOP principles (classes, objects, inheritance, encapsulation, polymorphism, and abstraction), programmers can leverage the full p
11 min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read