Question

2529. Maximum Count of Positive Integer and Negative Integer

中文文档

Description

Given an array nums sorted in non-decreasing order, return _the maximum between the number of positive integers and the number of negative integers._

• In other words, if the number of positive integers in 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] <= 2000
• nums is sorted in a non-decreasing order.

 

Follow up: Can you solve the problem in O(log(n)) time complexity?

Solutions

Solution 1

class Solution:
  def maximumCount(self, nums: List[int]) -> int:
    a = sum(v > 0 for v in nums)
    b = sum(v < 0 for v in nums)
    return max(a, b)

class Solution {
  public int maximumCount(int[] nums) {
    int a = 0, b = 0;
    for (int v : nums) {
      if (v > 0) {
        ++a;
      }
      if (v < 0) {
        ++b;
      }
    }
    return Math.max(a, b);
  }
}

class Solution {
public:
  int maximumCount(vector<int>& nums) {
    int a = 0, b = 0;
    for (int& v : nums) {
      if (v > 0) {
        ++a;
      }
      if (v < 0) {
        ++b;
      }
    }
    return max(a, b);
  }
};

func maximumCount(nums []int) int {
  a, b := 0, 0
  for _, v := range nums {
    if v > 0 {
      a++
    }
    if v < 0 {
      b++
    }
  }
  return max(a, b)
}

function maximumCount(nums: number[]): number {
  const count = [0, 0];
  for (const num of nums) {
    if (num < 0) {
      count[0]++;
    } else if (num > 0) {
      count[1]++;
    }
  }
  return Math.max(...count);
}

impl Solution {
  pub fn maximum_count(nums: Vec<i32>) -> i32 {
    let mut count = [0, 0];
    for &num in nums.iter() {
      if num < 0 {
        count[0] += 1;
      } else if num > 0 {
        count[1] += 1;
      }
    }
    *count.iter().max().unwrap()
  }
}

#define max(a, b) (((a) > (b)) ? (a) : (b))

int maximumCount(int* nums, int numsSize) {
  int count[2] = {0};
  for (int i = 0; i < numsSize; i++) {
    if (nums[i] < 0) {
      count[0]++;
    } else if (nums[i] > 0) {
      count[1]++;
    }
  }
  return max(count[0], count[1]);
}

Solution 2

class Solution:
  def maximumCount(self, nums: List[int]) -> int:
    a = len(nums) - bisect_left(nums, 1)
    b = bisect_left(nums, 0)
    return max(a, b)

class Solution {
  public int maximumCount(int[] nums) {
    int a = nums.length - search(nums, 1);
    int b = search(nums, 0);
    return Math.max(a, b);
  }

  private int search(int[] nums, int x) {
    int left = 0, right = nums.length;
    while (left < right) {
      int mid = (left + right) >> 1;
      if (nums[mid] >= x) {
        right = mid;
      } else {
        left = mid + 1;
      }
    }
    return left;
  }
}

class Solution {
public:
  int maximumCount(vector<int>& nums) {
    int a = nums.end() - lower_bound(nums.begin(), nums.end(), 1);
    int b = lower_bound(nums.begin(), nums.end(), 0) - nums.begin();
    return max(a, b);
  }
};

func maximumCount(nums []int) int {
  a := len(nums) - sort.SearchInts(nums, 1)
  b := sort.SearchInts(nums, 0)
  return max(a, b)
}

function maximumCount(nums: number[]): number {
  const search = (target: number) => {
    let left = 0;
    let right = n;
    while (left < right) {
      const mid = (left + right) >>> 1;
      if (nums[mid] < target) {
        left = mid + 1;
      } else {
        right = mid;
      }
    }
    return left;
  };
  const n = nums.length;
  const i = search(0);
  const j = search(1);
  return Math.max(i, n - j);
}

impl Solution {
  fn search(nums: &Vec<i32>, target: i32) -> usize {
    let mut left = 0;
    let mut right = nums.len();
    while left < right {
      let mid = (left + right) >> 1;
      if nums[mid] < target {
        left = mid + 1;
      } else {
        right = mid;
      }
    }
    left
  }

  pub fn maximum_count(nums: Vec<i32>) -> i32 {
    let n = nums.len();
    let i = Self::search(&nums, 0);
    let j = Self::search(&nums, 1);
    i.max(n - j) as i32
  }
}

#define max(a, b) (((a) > (b)) ? (a) : (b))

int search(int* nums, int numsSize, int target) {
  int left = 0;
  int right = numsSize;
  while (left < right) {
    int mid = (left + right) >> 1;
    if (nums[mid] < target) {
      left = mid + 1;
    } else {
      right = mid;
    }
  }
  return left;
}

int maximumCount(int* nums, int numsSize) {
  int i = search(nums, numsSize, 0);
  int j = search(nums, numsSize, 1);
  return max(i, numsSize - j);
}

Solution 3

impl Solution {
  pub fn maximum_count(nums: Vec<i32>) -> i32 {
    let mut a = 0;
    let mut b = 0;

    for n in nums {
      if n > 0 {
        a += 1;
      } else if n < 0 {
        b += 1;
      }
    }

    std::cmp::max(a, b)
  }
}