209. Minimum Size Subarray Sum – Leetcode Solutions

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

from typing import List

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        # Initialize the left pointer of the window, the sum of the current window, and the result length.
        left = 0
        current_sum = 0
        min_length = float('inf')  # Start with an infinite length for comparison
        
        # Iterate over the array with the right pointer.
        for right in range(len(nums)):
            # Add the current element to the current sum.
            current_sum += nums[right]
            
            # While the current window sum is greater than or equal to the target,
            # try to minimize the window by moving the left pointer to the right.
            while current_sum >= target:
                # Update the minimum length with the size of the current window.
                min_length = min(min_length, right - left + 1)
                # Subtract the element at the left pointer from the current sum and move the left pointer to the right.
                current_sum -= nums[left]
                left += 1
        
        # If the minimum length is still infinity, it means no valid subarray was found, return 0.
        return min_length if min_length != float('inf') else 0

/**
 * @param {number} target
 * @param {number[]} nums
 * @return {number}
 */
var minSubArrayLen = function(target, nums) {
    // Initialize the left pointer of the sliding window, the current sum of the window, and the minimal length.
    let left = 0;
    let currentSum = 0;
    let minLength = Infinity;  // Start with an infinitely large length for comparison

    // Iterate over the array with the right pointer.
    for (let right = 0; right < nums.length; right++) {
        // Add the current element at the right pointer to the current sum.
        currentSum += nums[right];

        // While the current window's sum is greater than or equal to the target,
        // try to minimize the window size by moving the left pointer to the right.
        while (currentSum >= target) {
            // Update the minimal length with the size of the current window.
            minLength = Math.min(minLength, right - left + 1);
            // Subtract the element at the left pointer from the current sum and move the left pointer to the right.
            currentSum -= nums[left];
            left++;
        }
    }

    // If the minimal length is still Infinity, it means no valid subarray was found, so return 0.
    // Otherwise, return the minimal length.
    return minLength === Infinity ? 0 : minLength;
};

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        // Initialize the left pointer of the sliding window, the current sum of the window, and the minimum length.
        int left = 0;
        int currentSum = 0;
        int minLength = Integer.MAX_VALUE; // Start with a very large value for comparison

        // Iterate over the array with the right pointer.
        for (int right = 0; right < nums.length; right++) {
            // Add the current element at the right pointer to the current sum.
            currentSum += nums[right];

            // While the current window's sum is greater than or equal to the target,
            // try to minimize the window size by moving the left pointer to the right.
            while (currentSum >= target) {
                // Update the minimal length with the size of the current window.
                minLength = Math.min(minLength, right - left + 1);
                // Subtract the element at the left pointer from the current sum and move the left pointer to the right.
                currentSum -= nums[left];
                left++;
            }
        }

        // If the minimal length is still the maximum integer value, it means no valid subarray was found, so return 0.
        // Otherwise, return the minimal length.
        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }
}

public class Solution {
    public int MinSubArrayLen(int target, int[] nums) {
        // Initialize the left pointer of the sliding window, the current sum of the window, and the minimum length.
        int left = 0;
        int currentSum = 0;
        int minLength = int.MaxValue; // Start with a very large value for comparison

        // Iterate over the array with the right pointer.
        for (int right = 0; right < nums.Length; right++) {
            // Add the current element at the right pointer to the current sum.
            currentSum += nums[right];

            // While the current window's sum is greater than or equal to the target,
            // try to minimize the window size by moving the left pointer to the right.
            while (currentSum >= target) {
                // Update the minimal length with the size of the current window.
                minLength = Math.Min(minLength, right - left + 1);
                // Subtract the element at the left pointer from the current sum and move the left pointer to the right.
                currentSum -= nums[left];
                left++;
            }
        }

        // If the minimal length is still int.MaxValue, it means no valid subarray was found, so return 0.
        // Otherwise, return the minimal length.
        return minLength == int.MaxValue ? 0 : minLength;
    }
}