Maximum Size Subarray Sum Equals k - Practice Coding Problems

Maximum Size Subarray Sum Equals k - Problem

You're given an integer array nums and a target integer k. Your mission is to find the maximum length of a contiguous subarray whose elements sum exactly to k.

A subarray is a contiguous sequence of elements within an array. For example, in array [1, 2, 3, 4], some subarrays include [1, 2], [2, 3, 4], and [1, 2, 3, 4].

Goal: Return the length of the longest subarray that sums to k. If no such subarray exists, return 0.

Example: In array [1, -1, 5, -2, 3] with k = 3, the subarray [5, -2] has sum 3 with length 2, but [1, -1, 5, -2, 3] also sums to 6... wait, that's not 3! The longest subarray summing to 3 is actually [3] with length 1, or we could have [1, -1, 5, -2] which sums to 3 with length 4!

Input & Output

example_1.py — Basic case with positive result

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

› Output: 4

💡 Note: The subarray [1, -1, 5, -2] has sum = 1 + (-1) + 5 + (-2) = 3 and length = 4. This is the longest subarray with sum equal to 3.

example_2.py — No valid subarray

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

› Output: 0

💡 Note: No subarray sums to 10. The maximum possible sum of any subarray is 1+2+3=6, which is less than 10.

example_3.py — Single element match

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

› Output: 1

💡 Note: Multiple subarrays sum to 2: [2] at index 1, [2] at index 3. Each has length 1, so the maximum length is 1.

Visualization

Tap to expand

Understanding the Visualization

Track Running Balance

Keep a cumulative sum (like your account balance after each day)

Record First Occurrences

Remember the first day you reached each balance amount

Look for Target Difference

When you see balance X, check if balance (X-k) was seen before

Calculate Period Length

The days between those two balances had a net change of exactly k

Key Takeaway

🎯 Key Insight: By tracking the first occurrence of each cumulative sum, we can instantly find the longest period with any target net change using the mathematical property: sum(i to j) = prefix_sum[j] - prefix_sum[i-1]

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 23

The optimal solution uses the prefix sum technique combined with a hash table. Key insight: if prefix_sum[j] - prefix_sum[i] = k, then the subarray from index i+1 to j sums to k. We store the first occurrence of each prefix sum to maximize the subarray length. Time: O(n), Space: O(n).

Common Approaches

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

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize hash table with {0: -1} to handle subarrays starting from index 0
Iterate through array, maintaining running prefix sum
For each position, check if (prefix_sum - k) exists in hash table
If found, calculate length and update maximum
Store current prefix_sum in hash table if not seen before
Return maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with prefix_sum=0, hash_map={0:-1}

Process element

Update prefix_sum, check if (prefix_sum - k) exists

Calculate length

If found, length = current_index - stored_index

Store new sum

Add current prefix_sum to hash_map if not present

Code -

solution.c — C

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

// Simple hash table implementation for this problem
#define HASH_SIZE 10007

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

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

void put(HashNode** table, int key, int value) {
    int idx = hash(key);
    HashNode* node = table[idx];
    
    while (node) {
        if (node->key == key) return; // Don't update existing
        node = node->next;
    }
    
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table[idx];
    table[idx] = newNode;
}

int get(HashNode** table, int key, int* found) {
    int idx = hash(key);
    HashNode* node = table[idx];
    
    while (node) {
        if (node->key == key) {
            *found = 1;
            return node->value;
        }
        node = node->next;
    }
    
    *found = 0;
    return -1;
}

int findMaxLength(int* nums, int numsSize, int k) {
    HashNode* table[HASH_SIZE] = {NULL};
    put(table, 0, -1);
    
    int prefixSum = 0;
    int maxLength = 0;
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        
        int found;
        int idx = get(table, prefixSum - k, &found);
        if (found) {
            int length = i - idx;
            if (length > maxLength) {
                maxLength = length;
            }
        }
        
        get(table, prefixSum, &found);
        if (!found) {
            put(table, prefixSum, i);
        }
    }
    
    return maxLength;
}

int main() {
    int nums[] = {1, -1, 5, -2, 3};
    int k = 3;
    printf("%d\n", findMaxLength(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with O(1) hash table operations

✓ Linear Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

Constraints

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

52.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler