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

You are given a binary array nums containing only the integers 0 and 1.

Return the number of subarrays in nums that have more 1's than 0's.

Since the answer may be very large, return it modulo 10⁹ + 7.

A subarray is a contiguous sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 9

💡 Note: Subarrays with more 1s than 0s: [1] at indices (0,0), (2,2), (3,3); [1,0,1] at (0,2); [0,1] at (1,2); [1,1] at (2,3); [1,0,1,1] at (0,3); [0,1,1] at (1,3); [1,1,0] at (2,4). Total = 9 subarrays.

Example 2 — All Ones

$ Input: nums = [1,1,1]

› Output: 6

💡 Note: All possible subarrays have more 1s than 0s: [1] appears 3 times, [1,1] appears 2 times, [1,1,1] appears 1 time. Total = 3+2+1 = 6 subarrays.

Example 3 — Single Element

$ Input: nums = [0]

› Output: 0

💡 Note: The only subarray [0] has 0 ones and 1 zero, so 0 ≤ 1, which means it doesn't have more ones than zeros.

Constraints

1 ≤ nums.length ≤ 10⁵
nums[i] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to transform the problem by treating 0s as -1s, making it a prefix sum problem where we count subarrays with positive sum. The optimized O(n²) approach uses running counts to avoid recomputation. Advanced solutions can achieve better complexity using data structures like Binary Indexed Trees. Time: O(n²), Space: O(1).

Common Approaches

✓ Brute Force - Check All Subarrays

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

For every starting position, examine all possible ending positions. Count the number of 1s and 0s in each subarray and increment result when 1s > 0s.

Optimized - Prefix Sum Approach

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

Instead of counting elements for each subarray from scratch, maintain running counts of 1s and 0s as we extend the subarray. This eliminates the innermost loop.

Prefix Sum with Hash Map

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

Convert 0s to -1s, so we need subarrays with positive sum. Use prefix sums and hash map to count subarrays efficiently. For each position, count how many previous prefix sums are smaller.

Brute Force - Check All Subarrays — Algorithm Steps

Iterate through each starting index
For each start, iterate through all ending indices
Count 1s and 0s in current subarray
If ones > zeros, increment result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Count Elements

For each subarray, count 1s and 0s

Compare

Check if ones > zeros, increment result

Code -

solution.c — C

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

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

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* ptr = line + 1;
    while (*ptr != ']') {
        nums[size++] = strtol(ptr, &ptr, 10);
        if (*ptr == ',') ptr++;
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: n starting positions × n ending positions × n elements to count

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler