Maximum Count of Positive Integer and Negative Integer

Maximum Count of Positive Integer and Negative Integer - Problem

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: 0 is neither positive nor negative.

Input & Output

Example 1 — More Negatives

$ Input: nums = [-2,-1,-1,1,2,3]

› Output: 3

💡 Note: There are 3 negative integers and 3 positive integers. Return max(3, 3) = 3.

Example 2 — More Positives

$ Input: nums = [-3,-2,-1,0,0,1,2]

› Output: 3

💡 Note: There are 3 negative integers and 2 positive integers. Return max(3, 2) = 3.

Example 3 — Only Positives

$ Input: nums = [5,20,66,1314]

› Output: 4

💡 Note: There are 0 negative integers and 4 positive integers. Return max(0, 4) = 4.

Constraints

1 ≤ nums.length ≤ 2000
-2000 ≤ nums[i] ≤ 2000
nums is sorted in non-decreasing order

Visualization

Tap to expand

Asked in

M Microsoft 15 a Amazon 12 🍎 Apple 8

The key insight is to leverage the sorted property of the array. While a linear scan works in O(n), we can use binary search to find the boundaries between negative, zero, and positive numbers in O(log n) time. Best approach depends on array size: linear for small arrays, binary search for large ones. Time: O(log n), Space: O(1)

Common Approaches

✓ Binary Search Optimization

⏱️ Time: O(log n) Space: O(1)

Since the array is sorted, we can use binary search to find the first non-negative number and the first positive number. This gives us the count of negatives and positives in O(log n) time.

Linear Count

⏱️ Time: O(n) Space: O(1)

Scan through each element in the array, increment counters for positive and negative numbers, then return the maximum count. Since 0 is neither positive nor negative, we skip it.

Binary Search Optimization — Algorithm Steps

Use binary search to find first index where nums[i] >= 0
Use binary search to find first index where nums[i] > 0
Calculate counts and return maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First >= 0

Binary search locates first non-negative number

Find First > 0

Binary search locates first positive number

Calculate Counts

Use boundaries to determine counts without scanning

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize) {
    int n = numsSize;
    
    // Binary search for first non-negative number
    int left = 0, right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < 0) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    int firstNonNegative = left;
    
    // Binary search for first positive number
    left = 0;
    right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] <= 0) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    int firstPositive = left;
    
    int negCount = firstNonNegative;
    int posCount = n - firstPositive;
    
    return negCount > posCount ? negCount : posCount;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(line + 1, ",]");
    
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Two binary searches, each taking O(log n) time

⚡ Linearithmic

Space Complexity

O(1)

Only uses a few variables for binary search

✓ Linear Space

35.0K Views

Medium Frequency

~10 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler