Minimum Size Subarray Sum

Minimum Size Subarray Sum - Problem

Given an array of positive integers nums and a positive integer target, return the minimal length of a subarray whose sum is greater than or equal to target.

If there is no such subarray, return 0 instead.

A subarray is a contiguous part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The subarray [4,3] has sum 7 which is ≥ target, and length 2 is minimal. Other valid subarrays like [2,3,1,2] have length 4.

Example 2 — Single Element

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

› Output: 1

💡 Note: Single element [4] already meets the target requirement with minimum length 1.

Example 3 — No Solution

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

› Output: 0

💡 Note: Total sum is 8 < 11, so no subarray can achieve target sum ≥ 11.

Constraints

1 ≤ target ≤ 10⁹
1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 45 a Amazon 38 G Google 32 M Microsoft 28

The key insight is to use a sliding window approach that expands to reach the target sum and contracts to find the minimum length. The optimal solution uses two pointers with O(n) time complexity, where each element is visited at most twice. Time: O(n), Space: O(1).

Common Approaches

✓ Binary Search on Answer

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

Instead of finding the answer directly, binary search on possible lengths from 1 to n. For each candidate length, check if any subarray of that length has sum ≥ target using sliding window.

Brute Force - Check All Subarrays

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

Generate all possible subarrays starting from each position, calculate their sums, and track the minimum length that meets or exceeds the target.

Sliding Window (Two Pointers)

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

Maintain a sliding window using left and right pointers. Expand the window by moving right pointer to increase sum. When sum reaches target, try to shrink from left to find minimum length.

Binary Search on Answer — Algorithm Steps

Binary search on length from 1 to n
For each mid length, use sliding window to check feasibility
If achievable, try smaller lengths (right = mid)
If not achievable, try larger lengths (left = mid + 1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Space

Binary search lengths from 1 to n

Check Feasibility

For each length, check if any subarray achieves target

Narrow Range

Adjust search based on feasibility

Code -

solution.c — C

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

int canAchieve(int* nums, int numsSize, int target, int length) {
    int currentSum = 0;
    for (int i = 0; i < length; i++) {
        currentSum += nums[i];
    }
    if (currentSum >= target) return 1;
    
    for (int i = length; i < numsSize; i++) {
        currentSum = currentSum - nums[i - length] + nums[i];
        if (currentSum >= target) return 1;
    }
    return 0;
}

int solution(int* nums, int numsSize, int target) {
    int left = 1, right = numsSize;
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canAchieve(nums, numsSize, target, mid)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%d\n", solution(nums, count, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Binary search runs O(log n) iterations, each checking all subarrays in O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only using variables for binary search bounds and sliding window pointers

✓ Linear Space

125.0K Views

High Frequency

~25 min Avg. Time

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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler