> For the complete documentation index, see [llms.txt](https://jaywin.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jaywin.gitbook.io/leetcode/solutions/0209-minimum-size-subarray-sum.md).

# 0209. Minimum Size Subarray Sum

<https://leetcode.com/problems/minimum-size-subarray-sum>

## Description

Given an array of positive integers `nums` and a positive integer `target`, return the minimal length of a **contiguous subarray** `[numsl, numsl+1, ..., numsr-1, numsr]` of which the sum is greater than or equal to `target`. If there is no such subarray, return `0` instead.

**Example 1:**

```
**Input:** target = 7, nums = [2,3,1,2,4,3]
**Output:** 2
**Explanation:** The subarray [4,3] has the minimal length under the problem constraint.
```

**Example 2:**

```
**Input:** target = 4, nums = [1,4,4]
**Output:** 1
```

**Example 3:**

```
**Input:** target = 11, nums = [1,1,1,1,1,1,1,1]
**Output:** 0
```

**Constraints:**

* `1 <= target <= 109`
* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 105`

**Follow up:** If you have figured out the `O(n)` solution, try coding another solution of which the time complexity is `O(n log(n))`.

## ac1: Sliding window

```java
class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        // edge cases
        if (nums == null || nums.length == 0 || s <= 0) {
            return 0;
        }

        int l = 0, r = 0, sum = 0, min = Integer.MAX_VALUE;
        for (;r < nums.length; r++) {
            sum += nums[r];

            while (sum >= s) {
                min = Math.min(min, r - l + 1);
                sum -= nums[l];
                l++;
            }
        }

        return min == Integer.MAX_VALUE ? 0 : min;
    }
}
// O(N) time, O(1) space
```

## ac2: Binary search in prefix sum array