Codestin Search App

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
✓ 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	O(n²)	O(n)	Use sliding window technique with prefix sums to efficiently check all valid subarray lengths

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each possible starting position
For each start, try all valid lengths from l to r
Calculate sum for each subarray
Track minimum positive sum found
Return result or -1 if no positive sum exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position 0

Check subarrays starting at index 0 with lengths l to r

Start Position 1

Move to next starting position and repeat

Track Minimum

Keep track of the minimum positive sum found

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) {
    int minPositiveSum = INT_MAX;
    int found = 0;
    
    // Try all possible starting positions
    for (int start = 0; start < numsSize; start++) {
        int currentSum = 0;
        // Try all lengths from l to r
        int maxLen = min(r, numsSize - start);
        for (int length = 1; length <= maxLen; length++) {
            currentSum += nums[start + length - 1];
            // Check if current length is valid and sum is positive
            if (length >= l && currentSum > 0) {
                minPositiveSum = min(minPositiveSum, currentSum);
                found = 1;
            }
        }
    }
    
    return found ? 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²×r)

For each of n starting positions, we check up to (r-l+1) lengths, and each sum calculation takes O(r) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track minimum sum and current calculations

✓ Linear 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler