Minimum Size Subarray Sum

                                            
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size();
        int minLength = INT_MAX;
        int sum = 0;
        int left = 0;
        
        for (int right = 0; right < n; right++) {
            sum += nums[right];
            
            while (sum >= target) {
                minLength = min(minLength, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }
        
        return (minLength != INT_MAX) ? minLength : 0;
    }
};

                                            
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int minLength = Integer.MAX_VALUE;
        
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {
                minLength = Math.min(minLength, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }
        
        return minLength == Integer.MAX_VALUE ? 0 : minLength;
    }
}

                                            
class Solution(object):
    def minSubArrayLen(self, target, nums):
        left, sum_, min_len = 0, 0, float('inf')
        for right in range(len(nums)):
            sum_ += nums[right]
            while sum_ >= target:
                min_len = min(min_len, right - left + 1)
                sum_ -= nums[left]
                left += 1
        return min_len if min_len != float('inf') else 0

                                            
int minSubArrayLen(int target, int* nums, int numsSize) {
    int minLen = INT_MAX;
    int sum = 0;
    int left = 0;
    
    for (int right = 0; right < numsSize; right++) {
        sum += nums[right];
        
        while (sum >= target) {
            minLen = fmin(minLen, right - left + 1);
            sum -= nums[left];
            left++;
        }
    }
    
    return minLen == INT_MAX ? 0 : minLen;
}

                                            
/**
 * @param {number} target
 * @param {number[]} nums
 * @return {number}
 */
const minSubArrayLen = (target, nums) => {
    let left = 0;
    let sum = 0;
    let minLength = Infinity;
    
    for (let right = 0; right < nums.length; right++) {
        sum += nums[right];
        
        while (sum >= target) {
            minLength = Math.min(minLength, right - left + 1);
            sum -= nums[left];
            left++;
        }
    }
    
    return minLength === Infinity ? 0 : minLength;
};

                                            
function minSubArrayLen(target: number, nums: number[]): number {
    let start = 0;
    let sum = 0;
    let minLength = Infinity;

    for (let end = 0; end < nums.length; end++) {
        sum += nums[end];

        while (sum >= target) {
            minLength = Math.min(minLength, end - start + 1);
            sum -= nums[start];
            start++;
        }
    }

    return minLength !== Infinity ? minLength : 0;
};

                                            
class Solution {
    /**
     * @param Integer $target
     */
    function minSubArrayLen($target, $nums) {
        $n = count($nums);
        $left = 0;
        $sum = 0;
        $minLen = PHP_INT_MAX;
        
        for ($right = 0; $right < $n; $right++) {
            $sum += $nums[$right];
            
            while ($sum >= $target) {
                $minLen = min($minLen, $right - $left + 1);
                $sum -= $nums[$left];
                $left++;
            }
        }
        
        return $minLen == PHP_INT_MAX ? 0 : $minLen;
    }
}

                                            
class Solution {
    func minSubArrayLen(_ target: Int, _ nums: [Int]) -> Int {
        var minLength = Int.max
        var sum = 0
        var left = 0
        
        for (index, num) in nums.enumerated() {
            sum += num
            
            while sum >= target {
                minLength = min(minLength, index - left + 1)
                sum -= nums[left]
                left += 1
            }
        }
        
        return minLength == Int.max ? 0 : minLength
    }
}

                                            
class Solution {
    fun minSubArrayLen(target: Int, nums: IntArray): Int {
        var minLength = Int.MAX_VALUE
        var sum = 0
        var left = 0
        
        for (right in nums.indices) {
            sum += nums[right]
            
            while (sum >= target) {
                minLength = minOf(minLength, right - left + 1)
                sum -= nums[left]
                left++
            }
        }
        
        return if (minLength == Int.MAX_VALUE) 0 else minLength
    }
}

To solve this coding challenge, we need to identify the smallest contiguous subarray within the given array of positive integers

nums

whose sum is at least equal to the given

target

. If no such subarray exists, we return 0. The most efficient way to solve this is by using a sliding window approach which operates in O(n) time complexity.

# Explanation:

Understanding Input and Output :

We have an input array
nums

of positive integers.
We have a
target

which is a positive integer.
Our goal is to identify the minimal length of the subarray whose sum is greater than or equal to
target

. If no such subarray exists, we return 0.

Intuition of Sliding Window :

The sliding window approach utilizes two pointers,
left

and
right

, to traverse the array and dynamically adjust the window of elements being considered.
We expand the window by moving the
right

pointer to the right, and once the sum of the window is greater than or equal to the target, we try shrinking the window from the left to find the smallest possible window that works.

Step-by-Step Explanation :

Start with
left

and
right

pointers at the beginning of the array.
Initialize a variable
current_sum

to hold the sum of the current window and
min_length

to store the minimal length of the valid subarray.
Expand the window by moving the
right

pointer to the right and add the value at
right

to
current_sum

.
Once
current_sum

is greater than or equal to
target

, update
min_length

with the minimum value between
min_length

and the length of the current window (
right - left + 1

).
Shrink the window by moving the
left

pointer to the right, subtract the value at
left

from
current_sum

, and check again if the window still satisfies the sum condition.
Continue this process until you traverse the entire array.

Handling Edge Cases :

If the array is empty or no subarray sums to the target, we should return 0.

# Detailed Steps in Pseudocode:

Here is the pseudocode for the problem with detailed comments:

                                            
# Initialize pointers and variables:
left_pointer = 0          # Starting position of the left pointer
current_sum = 0           # Sum of elements in the current window
min_length = ∞            # Initialize to infinity to find the minimum

# Traverse the array with right_pointer:
for right_pointer from 0 to length of nums - 1:
# Add the current element to the window sum
current_sum = current_sum + nums[right_pointer]

# Check if current window sum is greater than or equal to target
while current_sum >= target:
# Update the minimum length of the subarray
min_length = minimum(min_length, right_pointer - left_pointer + 1)

# Shrink the window by moving left_pointer to the right
current_sum = current_sum - nums[left_pointer]
left_pointer = left_pointer + 1

# If no valid subarray found, return 0, otherwise return min_length
if min_length == ∞:
return 0
else:
return min_length

# Explanation of Pseudocode:

Initialization :

left_pointer

is set to 0 indicating the start of the window.
current_sum

is initialized to 0, which will hold the sum of the current window.
min_length

is set to infinity, which helps to find the minimal length by always comparing and updating it to the smallest value found.

Right Pointer Loop :

right_pointer

moves from the start to the end of the array.
With each move, the value at
right_pointer

is added to
current_sum

.

Inner While Loop :

This loop executes as long as
current_sum

is greater than or equal to
target

.
min_length

is updated to the smaller value between its current value and the length of the current window (
right_pointer - left_pointer + 1

).
The window is then shrunk from the left by subtracting the value at the
left_pointer

from
current_sum

, and incrementing
left_pointer

.

Final Check :

After exiting the loop, if
min_length

was updated from infinity, it is returned as the result. Otherwise, 0 is returned indicating no such subarray was found.

By following these detailed steps and using the pseudocode, we can efficiently solve the given problem in O(n) time complexity, ensuring that we handle large arrays and targets effectively.