Maximum Count of Positive Integer and Negative Integer

Maximum Count of Positive Integer and Negative Integer - Problem

Given a sorted array nums in non-decreasing order, find the maximum between the count of positive integers and the count of negative integers.

Your task is to return max(positive_count, negative_count) where:

Positive integers: numbers greater than 0
Negative integers: numbers less than 0
Zero: is neither positive nor negative (ignore it)

Example: In array [-3, -2, -1, 0, 0, 1, 2], we have 3 negative numbers and 2 positive numbers, so we return max(3, 2) = 3.

Since the array is already sorted, we can use this property to our advantage for an efficient solution!

Input & Output

example_1.py — Basic Case

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

› Output: 3

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

example_2.py — With Zeros

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

› Output: 3

💡 Note: There are 3 negative integers and 2 positive integers. Zeros don't count. max(3, 2) = 3.

example_3.py — Only Positives

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

› Output: 4

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

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

In a sorted array: [negatives] [zeros] [positives]

Find Boundaries

Use binary search to find where negatives end and positives begin

Calculate Counts

Count = boundary_index calculations, no need to scan all elements

Key Takeaway

🎯 Key Insight: In a sorted array, we can use binary search to find boundaries between negative and positive numbers, allowing us to calculate counts in O(log n) time instead of scanning all elements in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

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

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables for binary search

✓ Linear Space

Constraints

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

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses binary search to find boundaries between negative and positive numbers in the sorted array. This achieves O(log n) time complexity compared to the brute force O(n) approach. The key insight is that in a sorted array, all negatives come first, followed by zeros, then positives - so we can find the boundaries efficiently and calculate counts mathematically.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Use binary search to find boundaries between negative and positive numbers
Brute Force (Linear Scan)	O(n)	O(1)	Count positive and negative numbers by scanning the entire array

Binary Search (Optimal) — Algorithm Steps

Use binary search to find the first index where nums[i] > 0
Use binary search to find the last index where nums[i] < 0
Calculate positive count = n - first_positive_index
Calculate negative count = last_negative_index + 1
Return max(positive_count, negative_count)

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First Positive

Binary search to find first index where nums[i] > 0

Find Last Negative

Binary search to find last index where nums[i] < 0

Calculate Counts

pos_count = n - first_pos_index, neg_count = last_neg_index + 1

Code -

solution.c — C

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

int maximumCount(int* nums, int numsSize) {
    int n = numsSize;
    
    // Find first positive number
    int left = 0, right = n;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] > 0) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    int firstPos = left;
    
    // Find last negative number
    left = -1;
    right = n - 1;
    while (left < right) {
        int mid = left + (right - left + 1) / 2;
        if (nums[mid] < 0) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    int lastNeg = left;
    
    int posCount = n - firstPos;
    int negCount = lastNeg + 1;
    
    return posCount > negCount ? posCount : negCount;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    printf("%d\n", maximumCount(nums, n));
    free(nums);
    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 using a few variables for binary search

✓ Linear Space

Constraints

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

28.4K Views

Medium Frequency

~8 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler