Minimum Positive Sum Subarray - Practice Coding Problems

Minimum Positive Sum Subarray - Problem

You're given an integer array nums and two integers l and r. Your task is to find the minimum positive sum among all contiguous subarrays whose length is between l and r (inclusive).

A subarray is a contiguous sequence of elements within the array. You need to consider all possible subarrays with lengths from l to r, calculate their sums, and return the smallest sum that is greater than 0.

If no such subarray exists (i.e., all valid subarrays have sums ≤ 0), return -1.

Example: For array [2, -1, 3, -4, 5] with l=2, r=3, we check subarrays of length 2 and 3. The subarray [2, -1] has sum 1, which might be our answer if it's the minimum positive sum found.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3, -2, 1, 4], l = 2, r = 3

› Output: 1

💡 Note: Valid subarrays: [3,-2] (sum=1), [-2,1] (sum=-1), [1,4] (sum=5), [3,-2,1] (sum=2), [-2,1,4] (sum=3). The minimum positive sum is 1.

example_2.py — No Positive Sum

$ Input: nums = [-1, -2, -3, -4], l = 2, r = 4

› Output: -1

💡 Note: All possible subarrays have negative sums, so we return -1.

example_3.py — Single Element

$ Input: nums = [1], l = 1, r = 1

› Output: 1

💡 Note: Only one valid subarray [1] with sum 1, which is positive.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ l ≤ r ≤ nums.length
-1000 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Scan the Store

Look at all possible starting positions in the store aisle

Try Different Cart Sizes

For each start position, try cart sizes from l to r items

Calculate Total Cost

Sum up costs (positive prices, negative discounts) for each combination

Track Minimum Spend

Keep track of the smallest positive total cost found

Key Takeaway

🎯 Key Insight: Use prefix sums to avoid recalculating subarray sums, turning an O(n³) problem into O(n²)

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses sliding window with prefix sums to efficiently calculate subarray sums in O(1) time. While still O(n²) overall, this eliminates redundant calculations and provides a clean, efficient solution for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Prefix Sums	O(n²)	O(n)	Use sliding window technique with prefix sums to efficiently check all valid subarray lengths
Brute Force (Nested Loops)	O(n²×r)	O(1)	Check all possible subarrays of valid lengths and track minimum positive sum

Sliding Window with Prefix Sums — Algorithm Steps

Calculate prefix sums for quick range sum queries
For each starting position, use sliding window for lengths l to r
Use prefix sums to calculate subarray sums in O(1) time
Track minimum positive sum across all valid subarrays
Return result or -1 if no positive sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Array

Create prefix sum array for O(1) range queries

Slide Window

For each start position, slide window through valid lengths

Quick Sum Calculation

Use prefix[end] - prefix[start] for instant sum

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int min(int a, int b) {
    return a < b ? a : b;
}

int minimumPositiveSumSubarray(int* nums, int numsSize, int l, int r) {
    // Calculate prefix sums
    long long* prefix = (long long*)calloc(numsSize + 1, sizeof(long long));
    for (int i = 0; i < numsSize; i++) {
        prefix[i + 1] = prefix[i] + nums[i];
    }
    
    long long minPositiveSum = LLONG_MAX;
    int found = 0;
    
    // Try all starting positions
    for (int start = 0; start < numsSize; start++) {
        // Try all valid lengths
        int maxLen = min(r, numsSize - start);
        for (int length = l; length <= maxLen; length++) {
            // Calculate sum using prefix sums: O(1) operation
            long long subarraySum = prefix[start + length] - prefix[start];
            if (subarraySum > 0) {
                if (subarraySum < minPositiveSum) {
                    minPositiveSum = subarraySum;
                }
                found = 1;
            }
        }
    }
    
    free(prefix);
    return found ? (int)minPositiveSum : -1;
}

int main() {
    int nums[] = {2, -1, 3, -4, 5};
    int l = 2, r = 3;
    printf("%d\n", minimumPositiveSumSubarray(nums, 5, l, r));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We check each starting position (O(n)) and for each position check up to (r-l+1) lengths (O(r)), but sum calculation is O(1)

⚠ Quadratic Growth

Space Complexity

O(n)

Additional space needed to store prefix sums array

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Sliding Window with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler