LeetCode link:[209. Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum),

[209. 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum)

LeetCode link:[209. Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum), difficulty:**Medium**.

[中文题解](#中文题解)

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 non-empty sequence of elements within an array.

Difficulty:**Medium**

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

**Output**:`0`

For**subarray** problems, you can consider using**Sliding Window Technique**, which is similar to the**Fast and Slow Pointers Technique**.

* Iterate over the`nums` array, the`index` of the element is named`fastIndex`. Although inconspicuous, this is the most important logic of the_Fast and Slow Pointers Technique_. Please memorize it.

*`sum += nums[fast_index]`.

1. Iterate over the`nums` array, the`index` of the element is named`fastIndex`. Although inconspicuous, this is the most important logic of the_Fast and Slow Pointers Technique_. Please memorize it.

2.`sum += nums[fast_index]`.

var minLength=Integer.MAX_VALUE;

var sum=0;

return minLength;

* Control of`slowIndex`:

3. Control of`slowIndex`:

var minLength=Integer.MAX_VALUE;

var sum=0;

给定一个含有`n` 个正整数的数组和一个正整数`target` 。

找出该数组中满足其总和大于等于`target` 的长度**最小的****子数组**`[numsl, numsl+1, ..., numsr-1, numsr]` ，并返回*其长度*。如果不存在符合条件的子数组，返回`0` 。

**子数组** 是数组中连续的**非空** 元素序列。

难度:**中等**

**输入**:`target = 7, nums = [2,3,1,2,4,3]`

**输出**:`2`

**解释**:`子数组 [4,3] 是该条件下的长度最小的子数组。`

1. 对于**子数组**问题，可以考虑使用**滑动窗口技术**，它类似于**快速和慢速指针技术**。

1.**遍历**`nums` 数组，元素的`index` 可命名为`fastIndex`。虽然不起眼，但这是`快慢指针技术`**最重要**的逻辑。请最好记住它。

2.`sum += nums[fast_index]`.

var minLength=Integer.MAX_VALUE;

var sum=0;

var slowIndex=0;

for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {// 本行是`快慢指针技术`最重要的逻辑

sum+= nums[fastIndex];// 1

}

return minLength;

3. 控制`slowIndex`。

var minLength=Integer.MAX_VALUE;

var sum=0;

var slowIndex=0;

for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {

sum+= nums[fastIndex];

while (sum>= target) {// 1

minLength=Math.min(minLength, fastIndex- slowIndex+1);// 2

sum-= nums[slowIndex];// 3

slowIndex++;// 4

}

}

if (minLength==Integer.MAX_VALUE) {// 5

return0;// 6

}

return minLength;

LeetCode link:[209. Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum),

[209. 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum)

力扣链接：[209. 长度最小的子数组](https://leetcode.cn/problems/minimum-size-subarray-sum) ，难度：**中等**。

[中文题解](#中文题解)

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.

给定一个含有`n` 个正整数的数组和一个正整数`target` 。

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

**输入**:`target = 7, nums = [2,3,1,2,4,3]`

**Output**:`2`

**输出**:`2`

**Explanation**:`The subarray[4,3] has the minimal length under the problem constraint.`

**解释**:`子数组 _[4,3]_ 是该条件下的长度最小的子数组。`

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

**输入**:`target = 4, nums = [1,4,4]`

**Output**:`1`

**输出**:`1`

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

**输入**:`target = 11, nums = [1,1,1,1,1,1,1,1]`

**Output**:`0`

**输出**:`0`

For**subarray** problems, you can consider using**Sliding Window Technique**, which is similar to the**Fast and Slow Pointers Technique**.

1. 对于**子数组**问题，可以考虑使用**滑动窗口技术**，它类似于**快速和慢速指针技术**。

*`sum += nums[fast_index]`.

2.`sum += nums[fast_index]`.

var minLength=Integer.MAX_VALUE;

var sum=0;

var slowIndex=0;

for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {//This line the most important logic of the `Fast and Slow Pointers Technique`.

for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {//本行是`快慢指针技术`最重要的逻辑

sum+= nums[fastIndex];// 1

}

return minLength;

var minLength=Integer.MAX_VALUE;

var sum=0;

return minLength;

*Time:`O(n)`.

*Space:`O(1)`.

*时间:`O(n)`.

*空间:`O(1)`.

给定一个含有`n` 个正整数的数组和一个正整数`target` 。

找出该数组中满足其总和大于等于`target` 的长度**最小的****子数组**`[numsl, numsl+1, ..., numsr-1, numsr]` ，并返回*其长度*。如果不存在符合条件的子数组，返回`0` 。

**子数组** 是数组中连续的**非空** 元素序列。

难度:**中等**

**输入**:`target = 7, nums = [2,3,1,2,4,3]`

**输出**:`2`

**解释**:`子数组 [4,3] 是该条件下的长度最小的子数组。`

1. 对于**子数组**问题，可以考虑使用**滑动窗口技术**，它类似于**快速和慢速指针技术**。

1.**遍历**`nums` 数组，元素的`index` 可命名为`fastIndex`。虽然不起眼，但这是`快慢指针技术`**最重要**的逻辑。请最好记住它。

2.`sum += nums[fast_index]`.

var minLength=Integer.MAX_VALUE;

var sum=0;

var slowIndex=0;

for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {// 本行是`快慢指针技术`最重要的逻辑

sum+= nums[fastIndex];// 1

}

return minLength;

3. 控制`slowIndex`。

var minLength=Integer.MAX_VALUE;

var sum=0;

var slowIndex=0;

for (var fastIndex=0; fastIndex< nums.length; fastIndex++) {

sum+= nums[fastIndex];

while (sum>= target) {// 1

minLength=Math.min(minLength, fastIndex- slowIndex+1);// 2

sum-= nums[slowIndex];// 3

slowIndex++;// 4

}

}

if (minLength==Integer.MAX_VALUE) {// 5

return0;// 6

}

return minLength;