leetcode

Author: ayoubzulfiqar

CountNegativeNumbersInASortedMatrix/count_negative_numbers_in_a_sorted_matrix.dart

@@ -0,0 +1,119 @@
+/*
+
+
+-* 1351. Count Negative Numbers in a Sorted Matrix *-
+
+Given a m x n matrix grid which is sorted in non-increasing order both row-wise and column-wise, return the number of negative numbers in grid.
+
+ 
+
+Example 1:
+
+Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
+Output: 8
+Explanation: There are 8 negatives number in the matrix.
+Example 2:
+
+Input: grid = [[3,2],[1,0]]
+Output: 0
+ 
+
+Constraints:
+
+m == grid.length
+n == grid[i].length
+1 <= m, n <= 100
+-100 <= grid[i][j] <= 100
+ 
+
+Follow up: Could you find an O(n + m) solution?
+
+
+
+
+
+*/
+
+class A {
+  int countNegatives(List<List<int>> grid) {
+    int count = 0;
+    final int rows = grid.length;
+    final int columns = grid[0].length;
+    int row = 0;
+    int column = columns - 1;
+    while (row < rows && column >= 0) {
+      if (grid[row][column] < 0) {
+        count += (column + 1);
+        row += 1;
+      } else {
+        column -= 1;
+      }
+    }
+    return count;
+  }
+}
+
+class B {
+  int countNegatives(List<List<int>> grid) {
+    int count = 0;
+    final int rows = grid.length;
+    final int cols = grid[0].length;
+    int row = rows - 1;
+    int col = 0;
+
+    while (col < cols && row >= 0) {
+      if (grid[row][col] < 0) {
+        count += cols - col;
+        row--;
+      } else {
+        col++;
+      }
+    }
+
+    return count;
+  }
+}
+
+class C {
+  int countNegatives(List<List<int>> grid) {
+    final int gridRowsLength = grid.length;
+    int count = 0;
+
+    for (int i = 0; i < gridRowsLength; i++) {
+      grid[i].sort();
+      final int upperBoundCalculation = binarySearch(grid[i], -1);
+      count += grid[i].length - upperBoundCalculation;
+    }
+
+    return count;
+  }
+
+  int binarySearch(List<int> list, int target) {
+    int start = 0;
+    int end = list.length;
+
+    while (start < end) {
+      final int mid = start + ((end - start) ~/ 2);
+      if (list[mid] > target) {
+        start = mid + 1;
+      } else {
+        end = mid;
+      }
+    }
+
+    return start;
+  }
+}
+
+class Solution {
+  int countNegatives(List<List<int>> grid) {
+    int count = 0;
+
+    for (List<int> row in grid) {
+      int ub = row.reversed.toList().lastIndexWhere((element) => element < 0);
+      count += ub + 1;
+    }
+
+    return count;
+  }
+}

CountNegativeNumbersInASortedMatrix/count_negative_numbers_in_a_sorted_matrix.go

@@ -0,0 +1,35 @@
+package main
+
+import "sort"
+
+func countNegatives1(grid [][]int) int {
+	var count int = 0
+	var rows int = len(grid)
+	var columns int = len(grid[0])
+	var row int = rows - 1
+	var column int = 0
+	for column < columns && row >= 0 {
+		if grid[row][column] < 0 {
+			count += columns - column
+			row--
+		} else {
+			column++
+		}
+	}
+	return count
+}
+
+func countNegatives(grid [][]int) int {
+	var gridRowsLength int = len(grid)
+	var count int = 0
+
+	for i := 0; i < gridRowsLength; i++ {
+		sort.Sort(sort.Reverse(sort.IntSlice(grid[i])))
+		upperBound := sort.Search(len(grid[i]), func(j int) bool {
+			return grid[i][j] < 0
+		})
+		count += len(grid[i]) - upperBound
+	}
+
+	return count
+}

CountNegativeNumbersInASortedMatrix/count_negative_numbers_in_a_sorted_matrix.md

@@ -0,0 +1,19 @@
+# A
+
+To count negative numbers in a sorted matrix, you can use a simple algorithm that takes advantage of the sorted property of the matrix. Here's a step-by-step approach to count negative numbers efficiently:
+
+1. Initialize a count variable to 0, which will store the number of negative numbers encountered.
+2. Start from the top-right corner of the matrix.
+3. Compare the current element with 0:
+   - If the current element is less than 0, it means the entire column to the left of the current element will also be negative. Increment the count variable by the number of elements in that column (including the current element).
+   - If the current element is greater than or equal to 0, move to the next row (go down).
+4. Repeat step 3 until you reach the bottom-left corner of the matrix.
+5. Return the count variable, which will contain the total count of negative numbers in the matrix.
+
+Here's a Python code implementation of the algorithm:
+
+```dart
+
+```
+
+You can use this function by passing your sorted matrix as an argument. It will return the count of negative numbers in the matrix.

README.md

@@ -224,6 +224,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [**405.** Convert a Number to Hexadecimal](ConvertANumberToHexadecimal/convert_a_number_to_hexadecimal.dart)
 - [**1502.** Can Make Arithmetic Progression From Sequence](CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.dart)
 - [**409.** Longest Palindrome](LongestPalindrome/longest_palindrome.dart)
+- [**1351.** Count Negative Numbers in a Sorted Matrix](CountNegativeNumbersInASortedMatrix/count_negative_numbers_in_a_sorted_matrix.dart)
 
 ## Reach me via