solves #2529: Maximum Count of Positive Integer and Negative Integer in java

Author: anishLearnsToCode

README.md

@@ -793,7 +793,7 @@
 | 2515 | [Shortest Distance to Target String in a Circular Array](https://leetcode.com/problems/shortest-distance-to-target-string-in-a-circular-array)                         |                                                                       [![Java](assets/java.png)](src/ShortestDistanceToTargetStringInACircularArray.java)                                                                        |                                                                                                                                   |
 | 2520 | [Count the Digits That Divide a Number](https://leetcode.com/problems/count-the-digits-that-divide-a-number)                                                           |                                                                               [![Java](assets/java.png)](src/CountTheDigitsThatDivideANumber.java)                                                                               |                                                                                                                                   |
 | 2525 | [Categorize Box According to Criteria](https://leetcode.com/problems/categorize-box-according-to-criteria)                                                             |                                                                              [![Java](assets/java.png)](src/CategorizeBoxAccordingToCriteria.java)                                                                               |                                                                                                                                   |
-| 2529 | [Maximum Count of Positive Integer and Negative Integer](https://leetcode.com/problems/maximum-count-of-positive-integer-and-negative-integer)                         |                                                                                                                                                                                                                                  |                                                                                                                                   |
+| 2529 | [Maximum Count of Positive Integer and Negative Integer](https://leetcode.com/problems/maximum-count-of-positive-integer-and-negative-integer)                         |                                                                       [![Java](assets/java.png)](src/MaximumCountOfPositiveIntegerAndNegativeInteger.java)                                                                       |                                                                                                                                   |
 | 2535 | [Difference Between Element Sum and Digit Sum of an Array](https://leetcode.com/problems/difference-between-element-sum-and-digit-sum-of-an-array)                     |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 2540 | [Minimum Common Value](https://leetcode.com/problems/minimum-common-value)                                                                                             |                                                                                                                                                                                                                                  |                                                                                                                                   |
 | 2544 | [Alternating Digit Sum](https://leetcode.com/problems/alternating-digit-sum)                                                                                           |                                                                                                                                                                                                                                  |                                                                                                                                   |

src/MaximumCountOfPositiveIntegerAndNegativeInteger.java

@@ -0,0 +1,39 @@
+// https://leetcode.com/problems/maximum-count-of-positive-integer-and-negative-integer
+// T: O(log(N))
+// S: O(1)
+
+public class MaximumCountOfPositiveIntegerAndNegativeInteger {
+    public int maximumCount(int[] nums) {
+        int firstIndex = binarySearchFirstIndex(nums, 0);
+        int lastIndex = binarySearchLastIndex(nums, 0);
+        return Math.max(firstIndex, nums.length - lastIndex - (lastIndex < nums.length && nums[lastIndex] == 0 ? 1 : 0));
+    }
+
+    // left leaning binary search with insertion point
+    private int binarySearchFirstIndex(int[] array, int x) {
+        int left = 0, right = array.length - 1, middle, index = -1;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (array[middle] == x) {
+                index = middle;
+                right = middle - 1;
+            } else if (array[middle] > x) right = middle - 1;
+            else left = middle + 1;
+        }
+        return index == -1 ? left : index;
+    }
+
+    // right leaning binary search with insertion point
+    private int binarySearchLastIndex(int[] array, int x) {
+        int left = 0, right = array.length - 1, middle, index = -1;
+        while (left <= right) {
+            middle = left + (right - left) / 2;
+            if (array[middle] == x) {
+                index = middle;
+                left = middle + 1;
+            } else if (array[middle] > x) right = middle - 1;
+            else left = middle + 1;
+        }
+        return index == -1 ? left : index;
+    }
+}