Binary Subarrays With Sum

Binary Subarrays With Sum - Problem

Given a binary array nums and an integer goal, return the number of non-empty subarrays with a sum equal to goal.

A subarray is a contiguous part of the array.

For example, if nums = [1,0,1,0,1] and goal = 2, we need to find all subarrays that sum to 2: [1,0,1], [0,1,0,1], and [1,0,1] (at different positions).

Input & Output

Example 1 — Basic Binary Array

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

› Output: 4

💡 Note: Four subarrays have sum 2: [1,0,1] at index 0-2, [0,1,0,1] at index 1-4, [1,0,1] at index 2-4, and [0,1] at index 3-4

Example 2 — All Ones

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

› Output: 2

💡 Note: Two subarrays have sum 2: [1,1] at index 0-1 and [1,1] at index 1-2

Example 3 — Goal Zero

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

› Output: 15

💡 Note: All possible subarrays of zeros sum to 0. With 5 elements, there are 5*6/2 = 15 total subarrays

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
nums[i] is either 0 or 1
0 ≤ goal ≤ nums.length

Visualization

Tap to expand

Asked in

F Facebook 25 G Google 20 a Amazon 15

The key insight is using prefix sums with a hash map to efficiently count subarrays. For each position, we check if (current_sum - goal) exists in our history. Best approach uses prefix sum + HashMap in O(n) time, O(n) space.

Common Approaches

✓ Prefix Sum with HashMap

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

Calculate running prefix sum and use hash map to store frequency of each sum seen. For each position, check if (current_sum - goal) exists in the map.

Brute Force - Check All Subarrays

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

For each starting position, extend the subarray one element at a time and check if the sum equals the goal. This examines every possible contiguous subarray.

Sliding Window (At Most Technique)

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

Since direct sliding window doesn't work for 'exactly goal', we use the trick: exactly(goal) = atMost(goal) - atMost(goal-1). For binary arrays, this works perfectly.

Prefix Sum with HashMap — Algorithm Steps

Maintain running prefix sum
Store frequency of each prefix sum in hash map
For each sum, check if (sum - goal) exists to form valid subarray

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Prefix

Keep running sum as we traverse

Check HashMap

Look for (current_sum - goal)

Count Found

Add frequency of matching sum

Code -

solution.c — C

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

#define MAX_SIZE 30000

struct HashNode {
    int key;
    int value;
    struct HashNode* next;
};

struct HashTable {
    struct HashNode* buckets[MAX_SIZE];
};

int hash(int key) {
    return abs(key) % MAX_SIZE;
}

int get(struct HashTable* table, int key) {
    int h = hash(key);
    struct HashNode* node = table->buckets[h];
    while (node) {
        if (node->key == key) return node->value;
        node = node->next;
    }
    return 0;
}

void put(struct HashTable* table, int key, int value) {
    int h = hash(key);
    struct HashNode* node = table->buckets[h];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    struct HashNode* newNode = malloc(sizeof(struct HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table->buckets[h];
    table->buckets[h] = newNode;
}

int solution(int* nums, int numsSize, int goal) {
    int count = 0;
    int prefixSum = 0;
    struct HashTable table = {0};
    put(&table, 0, 1); // Initialize with sum 0 having count 1
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        // Check if (prefixSum - goal) exists
        count += get(&table, prefixSum - goal);
        // Add current prefixSum to map
        put(&table, prefixSum, get(&table, prefixSum) + 1);
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[30000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int goal;
    scanf("%d", &goal);
    
    int result = solution(nums, numsSize, goal);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores up to n different prefix sums

⚡ Linearithmic Space

67.0K Views

Medium Frequency

~25 min Avg. Time

1.9K 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

Prefix Sum with HashMap — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler