Introduction

In this blog post, we will explore how to solve the LeetCode problem "2529" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like Chatmagic, we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

Problem Statement

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?

Explanation

Here's the breakdown of the solution:

• Binary Search for Boundaries: Exploit the sorted nature of the array to efficiently find the index of the first positive number and the last negative number using binary search. This avoids iterating through the entire array.

• Calculate Counts: Once the boundaries are found, calculate the number of positive and negative integers directly using index arithmetic.

• Return the Maximum: Return the larger of the positive and negative counts.

• Runtime & Storage Complexity: O(log n) time complexity, O(1) space complexity.

Code

    def maximumCount(nums: list[int]) -> int:
    """
    Given an array nums sorted in non-decreasing order, return the maximum between the number of positive integers and the number of negative integers.
    """
    n = len(nums)

    # Find the index of the first positive number using binary search
    left, right = 0, n - 1
    first_positive_index = n
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] > 0:
            first_positive_index = mid
            right = mid - 1
        else:
            left = mid + 1

    # Find the index of the last negative number using binary search
    left, right = 0, n - 1
    last_negative_index = -1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] < 0:
            last_negative_index = mid
            left = mid + 1
        else:
            right = mid - 1

    # Calculate the number of positive and negative integers
    positive_count = n - first_positive_index
    negative_count = last_negative_index + 1

    # Return the maximum of the two counts
    return max(positive_count, negative_count)