# Solving Leetcode Interviews in Seconds with AI: Find Two Non-overlapping Sub-arrays Each With Target Sum


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1477" 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 array of integers arr and an integer target. You have to find two non-overlapping sub-arrays of arr each with a sum equal target. There can be multiple answers so you have to find an answer where the sum of the lengths of the two sub-arrays is minimum. Return the minimum sum of the lengths of the two required sub-arrays, or return -1 if you cannot find such two sub-arrays.   Example 1:  Input: arr = [3,2,2,4,3], target = 3 Output: 2 Explanation: Only two sub-arrays have sum = 3 ([3] and [3]). The sum of their lengths is 2.  Example 2:  Input: arr = [7,3,4,7], target = 7 Output: 2 Explanation: Although we have three non-overlapping sub-arrays of sum = 7 ([7], [3,4] and [7]), but we will choose the first and third sub-arrays as the sum of their lengths is 2.  Example 3:  Input: arr = [4,3,2,6,2,3,4], target = 6 Output: -1 Explanation: We have only one sub-array of sum = 6.    Constraints:  1 <= arr.length <= 105 1 <= arr[i] <= 1000 1 <= target <= 108  

	# Explanation
	Here's a breakdown of the solution, followed by the Python code:

*   **Sliding Window & Prefix Minimum:** Use a sliding window to find all sub-arrays that sum to the target. Store the lengths of these sub-arrays. Employ a prefix minimum array to efficiently find the minimum length of a sub-array ending before a certain index.

*   **Iteration & Minimum Sum:** Iterate through the sub-array lengths found, using the prefix minimum to find the minimum length of a non-overlapping sub-array preceding the current one. Update the overall minimum sum of lengths.

*   **Return Result:** If no two such sub-arrays are found, return -1; otherwise, return the minimum sum of their lengths.

*   **Complexity:**
    *   Runtime: O(n)
    *   Storage: O(n)

	
	# Code
	```python
	def minSumOfLengths(arr, target):
    n = len(arr)
    min_len = float('inf')
    lengths = []

    # Find all sub-arrays with sum equal to target
    for i in range(n):
        curr_sum = 0
        for j in range(i, n):
            curr_sum += arr[j]
            if curr_sum == target:
                lengths.append((i, j))
                break
            elif curr_sum > target:
                break
                
    # Calculate prefix minimum lengths
    prefix_min = [float('inf')] * n
    last_end = -1
    min_so_far = float('inf')
    for i in range(n):
        prefix_min[i] = min_so_far
        for start, end in lengths:
            if end == i:
                min_so_far = min(min_so_far, end - start + 1)
                
    ans = float('inf')
    for start, end in lengths:
        length = end - start + 1
        if start > 0:
            ans = min(ans, length + prefix_min[start - 1])
    
    if ans == float('inf'):
        return -1
    else:
        return ans
	```