LeetCode – Minimum Size Subarray Sum (Java)

Given an array of n positive integers and a positive integer s, find the minimal length of a subarray of which the sum ≥ s. If there isn't one, return 0 instead.

For example, given the array [2,3,1,2,4,3] and s = 7, the subarray [4,3] has the minimal length of 2 under the problem constraint.

Analysis

We can use 2 points to mark the left and right boundaries of the sliding window. When the sum is greater than the target, shift the left pointer; when the sum is less than the target, shift the right pointer.

Java Solution - two pointers

A simple sliding window solution.

public int minSubArrayLen(int s, int[] nums) {
    if(nums==null || nums.length==1)
        return 0;
 
    int result = nums.length;
 
    int start=0;
    int sum=0;
    int i=0;
    boolean exists = false;
 
    while(i<=nums.length){
        if(sum>=s){
            exists=true; //mark if there exists such a subarray 
            if(start==i-1){
                return 1;
            }
 
            result = Math.min(result, i-start);
            sum=sum-nums[start];
            start++;
 
        }else{
            if(i==nums.length)
                break;
            sum = sum+nums[i];
            i++;    
        }
    }
 
    if(exists)
        return result;
    else
        return 0;
}

Similarly, we can also write it in a more readable way.

public int minSubArrayLen(int s, int[] nums) {
    if(nums==null||nums.length==0)
        return 0;
 
    int i=0; 
    int j=0;
    int sum=0;
 
    int minLen = Integer.MAX_VALUE;
 
    while(j<nums.length){
        if(sum<s){
            sum += nums[j];
            j++;        
        }else{
            minLen = Math.min(minLen, j-i);
            if(i==j-1)
                return 1;
 
            sum -=nums[i];
            i++;
        }
    }
 
    while(sum>=s){
        minLen = Math.min(minLen, j-i);
 
        sum -=nums[i++];
    }
 
    return minLen==Integer.MAX_VALUE? 0: minLen;
}

If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:

<pre><code> 
String foo = "bar";
</code></pre>

Kaushlendra Singh

var arr = [2,3,1,2,4,3] var s = 7
sum = arr[0] + arr[1] for(var i=0, j = 1 ; i < j && j< arr.length;){ if(sum < s){ j++ sum += arr[j] } else { i++ sum -= arr[i] } }
arr.slice(i,j)
Rishab Ghanti

Thanks for the reply Zaid!
Zaid Haq

Yes… It should be O(n), as both the ends of the window would slide through every number only once.
Rishab Ghanti

What is the time complexity of the above first code? Will it be O(n)?
mallika

Hi is my solution right?

public static int minSizeSubArray(int[] arrA, int target){
if(arrA == null || arrA.length == 0){
throw new IllegalArgumentException(“”);
}
int index = 0;
int result = Integer.MAX_VALUE;
int sum = 0;
for(int i = 0; i target){
sum = sum – arrA[index];
index++;
}
if(sum == target){
result = Math.min(result, (i – index)+1);
sum = sum – arrA[index];
index++;
}
}
return result;
}
Noe Alejandro Perez Domínguez

My solution using Java’s cousin. Scala.
def minSizeSubArraySum(xs: List[Int], s: Int): Int = {
def loop(step: Int): Int = if (xs.sliding(step).toList.exists(_.sum >= s)) step else loop(step + 1) if (xs.sum >= s) loop(1) else 0
}
Noe Alejandro Perez Domínguez

My solution using Java’s cousin. Scala.

def minSizeSubArraySum(xs: List[Int], s: Int): Int = {

def loop(step: Int): Int =
if (xs.sliding(step).toList.exists(_.sum >= s)) step
else loop(step + 1)

if (xs.sum >= s) loop(1) else 0

}
NewGuest

Gives wrong result for [4,1,2,2,3,3] and s = 7. The result expected is 2 but it gives 3
airjordan919

I want to share my solution here. I think it’s more concise 🙂

public int minSubArrayLen(int s, int[] nums) {
if (nums == null || nums.length == 0 || s <= 0) return 0;
int min = Integer.MAX_VALUE;
int i = 0, sum = 0;
for (int j = 0; j = s) {
min = Math.min(min, j – i + 1);
sum -= nums[i++];
}
}
return min == Integer.MAX_VALUE ? 0 : min;
}
NewGuest

For input int a[]={2,3,1,1,8,3} and sum 7 it is giving wrong results
Varun

Dude, did you not read the problem? It says n positive integers! In what world is -1 a positive integer??
Hung Vu

No. Sorting is not allowed here since that will alter the original arrangement of the numbers in the array. There is an implicit requirement that the initial order of the numbers in the array be preserved. Sorting will violate that requirement.
srrm

Yeah, looks like a sort is required.

For instance, array[-1, 1, 2, 1, 2, 1], sum = 4, returns 3 based on above algorithm.

But the same algo with the array being sorted returns the correct answer 2, as the sum of array [2, 2] is >= 4.
rjb

shoulldnt we have sorted the array before ?

LeetCode – Minimum Size Subarray Sum (Java)

Related posts: