Minimum Size Subarray Sum - Practice Coding Problems

Minimum Size Subarray Sum - Problem

Find the shortest contiguous subarray that meets a sum threshold!

You're given an array of positive integers nums and a positive integer target. Your mission is to find the minimal length of a contiguous subarray whose sum is greater than or equal to the target value.

🎯 Goal: Return the length of the shortest qualifying subarray
📝 Special case: If no such subarray exists, return 0

This classic problem tests your ability to optimize from a brute force O(n²) solution to an elegant O(n) sliding window approach!

Input & Output

example_1.py — Basic Case

$ Input: target = 7, nums = [2,3,1,2,4,3]

› Output: 2

💡 Note: The subarray [4,3] has the minimal length 2 under the problem constraint. Other valid subarrays include [2,3,1,2] with length 4, but we want the shortest one.

example_2.py — Single Element

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

› Output: 1

💡 Note: The subarray [4] has the minimal length 1. Since 4 >= 4, a single element is sufficient.

example_3.py — No Solution

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

› Output: 0

💡 Note: The target sum 11 cannot be achieved with any subarray since the total sum is only 8. Therefore, return 0.

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with both pointers at the beginning, window size = 0

Expand Window

Move right pointer to include more elements until sum >= target

Contract Window

Move left pointer to shrink window while maintaining sum >= target

Track Minimum

Record the smallest valid window size encountered

Continue Process

Keep expanding and contracting until right pointer reaches end

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n²) brute force approach into an elegant O(n) solution by intelligently expanding and contracting a window, leveraging the property that all array elements are positive.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have two nested loops: outer loop runs n times, inner loop runs up to n times in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current sum, minimum length, and loop indices

✓ Linear Space

Constraints

1 ≤ target ≤ 10⁹
1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
All integers are positive (crucial for sliding window approach)

Asked in

f Facebook 85 a Amazon 72 G Google 68 ⊞ Microsoft 54 Apple 41

The optimal solution uses a sliding window (two pointers) technique achieving O(n) time complexity. We expand the window by moving the right pointer until the sum meets our target, then contract from the left while maintaining the condition. This approach leverages the fact that all numbers are positive, ensuring we never miss optimal solutions when shrinking the window.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray and find the shortest one that meets the target
Prefix Sum + Binary Search	O(n log n)	O(n)	Use prefix sums with binary search to find minimum subarray length
Sliding Window (Two Pointers)	O(n)	O(1)	Use expanding and contracting window to find minimum length efficiently

Brute Force (Check All Subarrays) — Algorithm Steps

For each starting index i, initialize sum to 0
Extend the subarray by adding elements from index i onwards
When sum >= target, record the current length
Continue checking all possibilities
Return the minimum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from index 0

Try subarrays [0], [0,1], [0,1,2]... until sum >= target

Start from index 1

Try subarrays [1], [1,2], [1,2,3]... until sum >= target

Continue for all positions

Repeat process for each starting index

Track minimum length

Keep track of the shortest subarray found so far

Code -

solution.c — C

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

int minSubArrayLen(int target, int* nums, int numsSize) {
    int minLength = INT_MAX;
    
    // Try all possible starting positions
    for (int i = 0; i < numsSize; i++) {
        int currentSum = 0;
        // Extend subarray from position i
        for (int j = i; j < numsSize; j++) {
            currentSum += nums[j];
            // Check if we've reached the target
            if (currentSum >= target) {
                int length = j - i + 1;
                if (length < minLength) {
                    minLength = length;
                }
                break; // Found minimum for this starting position
            }
        }
    }
    
    return minLength == INT_MAX ? 0 : minLength;
}

int main() {
    int target;
    scanf("%d", &target);
    
    int nums[1000];
    int size = 0;
    int num;
    while (scanf("%d", &num) == 1) {
        nums[size++] = num;
    }
    
    printf("%d\n", minSubArrayLen(target, nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have two nested loops: outer loop runs n times, inner loop runs up to n times in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current sum, minimum length, and loop indices

✓ Linear Space

Constraints

1 ≤ target ≤ 10⁹
1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴
All integers are positive (crucial for sliding window approach)

94.2K Views

High Frequency

~18 min Avg. Time

2.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 (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler