Binary Subarrays With Sum - Practice Coding Problems

Binary Subarrays With Sum - Problem

Given a binary array nums (containing only 0s and 1s) and an integer goal, your task is to find the number of non-empty contiguous subarrays whose elements sum exactly to the goal.

A subarray is a contiguous part of the array. For example, in array [1,0,1,0,1], the subarrays [1,0], [0,1,0], and [1,0,1,0,1] are all valid contiguous subarrays.

Your goal: Count how many such subarrays exist that sum to exactly goal.

Example: If nums = [1,0,1,0,1] and goal = 2, we need to find subarrays that sum to 2. The valid subarrays are [1,0,1] at indices 0-2, and [0,1,0,1] at indices 1-4, giving us a total count of 4 subarrays.

Input & Output

example_1.py — Basic Case

$ Input: {"nums": [1,0,1,0,1], "goal": 2}

› Output: 4

💡 Note: The 4 subarrays with sum 2 are: [1,0,1] at indices (0,2), [0,1] at indices (1,2), [1] at index (2), and [0,1,0,1] at indices (1,4). Note that [1] at index (4) also has sum 1, not 2.

example_2.py — Goal Zero

$ Input: {"nums": [0,0,0,0,0], "goal": 0}

› Output: 15

💡 Note: Every subarray sums to 0. With 5 elements, we have 5+4+3+2+1 = 15 possible subarrays: 5 single elements, 4 pairs, 3 triplets, 2 quadruplets, and 1 quintuplet.

example_3.py — No Valid Subarrays

$ Input: {"nums": [1,1,1], "goal": 5}

› Output: 0

💡 Note: The maximum possible sum is 3 (all elements), which is less than the goal of 5. Therefore, no subarrays can sum to 5.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Track Your Wealth

Keep a running total of coins collected (prefix sum)

Remember Past Wealth

Record every wealth level you've achieved in your logbook (hash map)

Find Valid Routes

At each step, check if you've been at wealth level (current - goal) before

Count Treasures

Each time you find a match, you've discovered valid treasure routes!

Key Takeaway

🎯 Key Insight: By tracking all wealth levels we've seen before, we can instantly identify when we've found a treasure route by checking if we've been at wealth level (current - goal) previously!

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 25

The optimal solution uses prefix sums with a hash map to achieve O(n) time complexity. The key insight is that for any subarray with sum equal to goal, we need prefix_sum[j] - prefix_sum[i-1] = goal, which means we're looking for prefix_sum[i-1] = current_sum - goal. By maintaining a hash map of prefix sum frequencies, we can count valid subarrays in a single pass.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum with Hash Map (Optimal)	O(n)	O(n)	Use prefix sums and hash map to find subarrays in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray by trying all start and end positions

Prefix Sum with Hash Map (Optimal) — Algorithm Steps

Initialize hash map with {0: 1} to handle subarrays starting from index 0
Iterate through array, maintaining running prefix sum
For each position, check if (current_sum - goal) exists in hash map
Add the frequency of (current_sum - goal) to result count
Update hash map with current prefix sum frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with hash map containing {0: 1}

Track prefix sum

Maintain running sum as we traverse

Find complement

Look for (current_sum - goal) in hash map

Update counts

Add current prefix sum to hash map

Code -

solution.c — C

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

#define MAX_SIZE 1000

// Simple hash table implementation
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;
}

void put(struct HashTable* ht, int key, int value) {
    int index = hash(key);
    struct HashNode* node = ht->buckets[index];
    
    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 = ht->buckets[index];
    ht->buckets[index] = newNode;
}

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

int numSubarraysWithSum(int* nums, int numsSize, int goal) {
    struct HashTable ht = {0};
    put(&ht, 0, 1); // Initialize with 0 sum having count 1
    
    int prefixSum = 0;
    int result = 0;
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        int target = prefixSum - goal;
        result += get(&ht, target);
        put(&ht, prefixSum, get(&ht, prefixSum) + 1);
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_SIZE];
    int numsSize = 0;
    int goal;
    
    char* start = strchr(line, '[') + 1;
    char* end = strchr(line, ']');
    *end = '\0';
    
    char* token = strtok(start, ",");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    char* goalStr = strstr(line, "goal") + 6;
    goal = atoi(goalStr);
    
    printf("%d\n", numSubarraysWithSum(nums, numsSize, goal));
    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 can store at most n+1 different prefix sums

⚡ Linearithmic Space

42.3K Views

High Frequency

~18 min Avg. Time

1.8K 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 Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler