Leetcode Minimum Size Subarray Sum problem solution

In this Leetcode Minimum Size Subarray Sum problem solution 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.

Problem solution in Python.

class Solution(object):
    def minSubArrayLen(self, s, nums):
        res = float("inf")
        if(nums):
            i=0
            window,currWindowSum = 0,0
            while(i+window<len(nums)):
                currWindowSum+=nums[i+window]
                if(currWindowSum>=s):
                    while(currWindowSum>=s): 
                        res=min(window+1,res)
                        currWindowSum-=nums[i] 
                        i+=1
                        window-=1
                window+=1
        return 0 if(res==float("inf")) else res

Problem solution in Java.

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

Problem solution in C++.

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int left = 0, right = 0;
        int res = INT_MAX;
        int cnt = 0;
        while(right < nums.size()){
            cnt += nums[right];
            while(left <= right && cnt >= s){
                res = min(res, right-left+1);
                cnt -= nums[left];
                left++;
            }
            right++;
        }
        return res == INT_MAX ? 0 : res;
    }
};

Problem solution in C.

int minSubArrayLen(int s, int* nums, int numsSize) {
    int *slowRunner, *fastRunner;
    int sumSoFar;
    int shortest;
    int curLength;
    
    slowRunner = fastRunner = nums;
    sumSoFar = 0;
    shortest = numsSize;
    
    while (fastRunner < nums + numsSize) {
        sumSoFar += *fastRunner;
        fastRunner++;   
   
        while (sumSoFar >= s) {
            sumSoFar -= *(slowRunner++);
            curLength = fastRunner - slowRunner + 1;
            shortest = curLength < shortest ? curLength : shortest; 
        }
    }
    return fastRunner - slowRunner == numsSize ? 0 : shortest;
}