Count Subarrays With More Ones Than Zeros

Count Subarrays With More Ones Than Zeros - Problem

Array Hash Table Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Medium

Imagine you're analyzing a series of binary signals where 1 represents success and 0 represents failure. Your task is to find all possible contiguous segments where successes outnumber failures.

Given a binary array nums containing only 0s and 1s, return the number of subarrays that have more 1's than 0's. Since the answer could be astronomically large, return it modulo 10⁹ + 7.

What's a subarray? A subarray is any contiguous sequence of elements within the array. For example, in [1,0,1], the subarrays are: [1], [0], [1], [1,0], [0,1], and [1,0,1].

Input & Output

example_1.py — Basic Case

$ Input: [1, 0, 1]

› Output: 2

💡 Note: Valid subarrays are [1] and [1, 0, 1]. The subarray [1] has 1 one and 0 zeros. The subarray [1, 0, 1] has 2 ones and 1 zero.

example_2.py — All Ones

$ Input: [1, 1, 1]

› Output: 6

💡 Note: All possible subarrays have more ones than zeros: [1], [1], [1], [1,1], [1,1], [1,1,1]. That's 6 total subarrays.

example_3.py — Mixed Array

$ Input: [1, 0, 1, 1, 0]

› Output: 9

💡 Note: Valid subarrays: [1], [1,0,1], [1,0,1,1], [1], [1,1], [1,1,0], [1], [1,0], [1,0,1,1,0]. Total count is 9.

Visualization

Tap to expand

Understanding the Visualization

Transform the Problem

Convert losses to -1 points, wins stay +1. Now we need sequences with positive total points.

Track Running Score

Calculate cumulative score after each game. This gives us prefix sums.

Count Winning Streaks

For each game, count how many previous scores were lower than current score.

Key Takeaway

🎯 Key Insight: Transform the problem mathematically - convert 0s to -1s and use prefix sums to efficiently count subarrays with positive sums, which correspond to sequences where wins outnumber losses.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for traversal, but we need O(log n) for each lookup to count smaller elements, achieved using ordered data structures

⚡ Linearithmic

Space Complexity

O(n)

Hash map to store all prefix sum frequencies

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Return answer modulo 10⁹ + 7

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses prefix sum transformation where 0s become -1s, converting the problem to counting subarrays with positive sums. By maintaining prefix sums in sorted order and using binary search, we can efficiently count valid subarrays in O(n log n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray and count 1s vs 0s
Prefix Sum with Hash Map (Optimal)	O(n log n)	O(n)	Transform problem using prefix sums and count efficiently with hash map

Brute Force (Check All Subarrays) — Algorithm Steps

Use two nested loops to generate all possible subarrays
For each subarray, count the number of 1s and 0s
If count of 1s > count of 0s, increment the result
Return the total count modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Use nested loops to create all possible subarrays

Count Elements

For each subarray, count 1s and 0s

Compare & Count

If 1s > 0s, increment result counter

Code -

solution.c — C

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

int countSubarrays(int* nums, int numsSize) {
    const int MOD = 1000000007;
    long long count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int ones = 0, zeros = 0;
        for (int j = i; j < numsSize; j++) {
            if (nums[j] == 1) ones++;
            else zeros++;
            
            if (ones > zeros) {
                count = (count + 1) % MOD;
            }
        }
    }
    
    return (int)count;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int reading = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (reading) {
            nums[size++] = num;
            num = 0;
            reading = 0;
        }
    }
    if (reading) nums[size++] = num;
    
    printf("%d\n", countSubarrays(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops O(n²) to generate subarrays, and O(n) to count elements in each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1
Return answer modulo 10⁹ + 7

21.8K Views

Medium Frequency

~25 min Avg. Time

842 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

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler