Subarray Sum Equals K - Practice Coding Problems

Subarray Sum Equals K - Problem

Given an array of integers nums and an integer k, find the total number of contiguous subarrays whose sum equals k. A subarray is a contiguous non-empty sequence of elements within an array. For example, in the array [1, 2, 3, 4], the subarrays are [1], [1,2], [1,2,3], [2], [2,3], [3], and so on. Your task: Count how many of these contiguous subarrays have a sum that equals the target value k.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: There are 2 subarrays with sum 2: [1,1] starting at index 0, and [1,1] starting at index 1

example_2.py — Mixed Numbers

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

› Output: 2

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

example_3.py — Negative Numbers

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

› Output: 3

💡 Note: Three subarrays sum to 0: [0], [1,-1], and [1,-1,0]

Visualization

Tap to expand

Understanding the Visualization

Track Running Balance

Keep a running total (prefix sum) as we process each transaction

Use History

For each current balance, check if we've seen (current_balance - k) before

Count Periods

If we found (current - k) previously, it means there's a period with exactly k change

Key Takeaway

🎯 Key Insight: Instead of checking all subarrays (O(n²)), we use prefix sums and hash map to find the answer in O(n) time by leveraging the mathematical relationship: prefix[j] - prefix[i] = k

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n different prefix sums in worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-1000 ≤ nums[i] ≤ 1000
-10⁷ ≤ k ≤ 10⁷
Note: The array can contain negative numbers, zero, and positive numbers

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses prefix sums with a hash map to solve this in O(n) time. The key insight is that if prefix_sum[j] - prefix_sum[i] = k, then the subarray from i+1 to j has sum k. We store frequencies of prefix sums in a hash map and look for (current_prefix_sum - k) to count valid subarrays ending at each position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray by trying all start and end positions
One-Pass Hash Table (Optimal)	O(n)	O(n)	Use prefix sums with hash map to count subarrays in single pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each possible starting index i
For each starting index, iterate through each possible ending index j >= i
Calculate the sum of elements from index i to j
If the sum equals k, increment the counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Check all subarrays starting at index 0

Move to index 1

Check all subarrays starting at index 1

Continue until end

Repeat for each starting position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <cjson/cJSON.h>

int subarraySum(int* nums, int numsSize, int k) {
    int count = 0;
    
    // Try every possible starting position
    for (int i = 0; i < numsSize; i++) {
        int currentSum = 0;
        // Try every possible ending position from current start
        for (int j = i; j < numsSize; j++) {
            currentSum += nums[j];
            if (currentSum == k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char buffer[10000];
    fgets(buffer, sizeof(buffer), stdin);
    
    cJSON *json = cJSON_Parse(buffer);
    cJSON *numsJson = cJSON_GetObjectItem(json, "nums");
    cJSON *kJson = cJSON_GetObjectItem(json, "k");
    
    int numsSize = cJSON_GetArraySize(numsJson);
    int *nums = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        nums[i] = cJSON_GetArrayItem(numsJson, i)->valueint;
    }
    
    int k = kJson->valueint;
    printf("%d\n", subarraySum(nums, numsSize, k));
    
    free(nums);
    cJSON_Delete(json);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have two nested loops, each potentially running n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
-1000 ≤ nums[i] ≤ 1000
-10⁷ ≤ k ≤ 10⁷
Note: The array can contain negative numbers, zero, and positive numbers

42.3K Views

Very High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler