# Solving Leetcode Interviews in Seconds with AI: Minimum Positive Sum Subarray


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3364" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an integer array nums and two integers l and r. Your task is to find the minimum sum of a subarray whose size is between l and r (inclusive) and whose sum is greater than 0. Return the minimum sum of such a subarray. If no such subarray exists, return -1. A subarray is a contiguous non-empty sequence of elements within an array.   Example 1:  Input: nums = [3, -2, 1, 4], l = 2, r = 3 Output: 1 Explanation: The subarrays of length between l = 2 and r = 3 where the sum is greater than 0 are:  [3, -2] with a sum of 1 [1, 4] with a sum of 5 [3, -2, 1] with a sum of 2 [-2, 1, 4] with a sum of 3  Out of these, the subarray [3, -2] has a sum of 1, which is the smallest positive sum. Hence, the answer is 1.  Example 2:  Input: nums = [-2, 2, -3, 1], l = 2, r = 3 Output: -1 Explanation: There is no subarray of length between l and r that has a sum greater than 0. So, the answer is -1.  Example 3:  Input: nums = [1, 2, 3, 4], l = 2, r = 4 Output: 3 Explanation: The subarray [1, 2] has a length of 2 and the minimum sum greater than 0. So, the answer is 3.    Constraints:  1 <= nums.length <= 100 1 <= l <= r <= nums.length -1000 <= nums[i] <= 1000  

	# Explanation
	Here's the solution to the problem:

*   **Prefix Sum Optimization:** Calculate prefix sums to efficiently compute the sum of any subarray in O(1) time.
*   **Sliding Window with Minimum Tracking:** Iterate through all possible subarray lengths between `l` and `r`. Use a sliding window approach within each length to compute subarray sums and track the minimum positive sum encountered so far.
*   **Early Exit:** If a positive sum is not found after checking all subarrays, return -1.

*   **Runtime Complexity:** O(n\*r) where n is the length of nums and r is the upper bound of subarray size.  **Storage Complexity:** O(n) due to the prefix sum array.

	
	# Code
	```python
	def min_subarray_sum(nums, l, r):
    n = len(nums)
    prefix_sum = [0] * (n + 1)
    for i in range(n):
        prefix_sum[i + 1] = prefix_sum[i] + nums[i]

    min_sum = float('inf')
    found = False

    for length in range(l, r + 1):
        for i in range(n - length + 1):
            subarray_sum = prefix_sum[i + length] - prefix_sum[i]
            if subarray_sum > 0:
                min_sum = min(min_sum, subarray_sum)
                found = True

    if found:
        return min_sum
    else:
        return -1
	```