Given an array nums sorted in non-decreasing order, return the maximum between the number of positive integers and the number of negative integers.
nums is pos and the number of negative integers is neg, then return the maximum of pos and neg.Note that 0 is neither positive nor negative.
Example 1:
Input: nums = [-2,-1,-1,1,2,3] Output: 3 Explanation: There are 3 positive integers and 3 negative integers. The maximum count among them is 3.
Example 2:
Input: nums = [-3,-2,-1,0,0,1,2] Output: 3 Explanation: There are 2 positive integers and 3 negative integers. The maximum count among them is 3.
Example 3:
Input: nums = [5,20,66,1314] Output: 4 Explanation: There are 4 positive integers and 0 negative integers. The maximum count among them is 4.
Constraints:
1 <= nums.length <= 2000-2000 <= nums[i] <= 2000nums is sorted in a non-decreasing order.
Follow up: Can you solve the problem in O(log(n)) time complexity?
class Solution {
public int maximumCount(int[] nums) {
int n = nums.length, lt = 0, rt = n - 1, neg = n, pos = n;
while (lt <= rt) {
int mid = (lt + rt) / 2;
if (nums[mid] < 0)
lt = mid + 1;
else {
rt = mid - 1;
neg = mid;
}
}
rt = n - 1;
while (lt <= rt) {
int mid = (lt + rt) / 2;
if (nums[mid] > 0) {
rt = mid - 1;
pos = mid;
} else
lt = mid + 1;
}
// System.out.println(pos + "\t" + neg);
return Math.max(n - pos, neg);
}
}class Solution {
public int maximumCount(int[] nums) {
int pos = 0, neg = 0;
for (int i : nums)
if (i > 0)
pos++;
else if (i < 0)
neg++;
return Math.max(pos, neg);
}
}class Solution {
public int maximumCount(int[] nums) {
int n = nums.length, lt = 0, rt = n - 1, neg = n, pos = n;
while (lt <= rt) {
int mid = (lt + rt) / 2;
if (nums[mid] < 0)
lt = mid + 1;
else {
rt = mid - 1;
neg = mid;
}
}
rt = n - 1;
while (lt <= rt) {
int mid = (lt + rt) / 2;
if (nums[mid] > 0) {
rt = mid - 1;
pos = mid;
} else
lt = mid + 1;
}
// System.out.println(pos + "\t" + neg);
return Math.max(n - pos, neg);
}
}