# Solving Leetcode Interviews in Seconds with AI: Count of Range Sum


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "327" 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
	> Given an integer array nums and two integers lower and upper, return the number of range sums that lie in [lower, upper] inclusive. Range sum S(i, j) is defined as the sum of the elements in nums between indices i and j inclusive, where i <= j.   Example 1:  Input: nums = [-2,5,-1], lower = -2, upper = 2 Output: 3 Explanation: The three ranges are: [0,0], [2,2], and [0,2] and their respective sums are: -2, -1, 2.  Example 2:  Input: nums = [0], lower = 0, upper = 0 Output: 1    Constraints:  1 <= nums.length <= 105 -231 <= nums[i] <= 231 - 1 -105 <= lower <= upper <= 105 The answer is guaranteed to fit in a 32-bit integer.  

	# Explanation
	Here's the solution to count range sums within a given range efficiently:

*   **Prefix Sums:** Calculate the prefix sums of the input array. This allows us to compute the sum of any range `nums[i:j+1]` in O(1) time by subtracting prefix sums.
*   **Merge Sort with Counting:** Use a modified merge sort algorithm. During the merge step, count the number of prefix sums in the right subarray that, when subtracted from a prefix sum in the left subarray, fall within the specified `[lower, upper]` range.
*   **Divide and Conquer:** Recursively divide the prefix sum array into smaller subarrays until each subarray contains only one element. Then, merge the sorted subarrays while counting the range sums that satisfy the condition.

*   **Time Complexity:** O(n log n), **Space Complexity:** O(n)

	
	# Code
	```python
	def countRangeSum(nums, lower, upper):
    n = len(nums)
    prefix_sums = [0] * (n + 1)
    for i in range(n):
        prefix_sums[i + 1] = prefix_sums[i] + nums[i]

    def merge_sort(sums, left, right):
        if left >= right:
            return 0

        mid = (left + right) // 2
        count = merge_sort(sums, left, mid) + merge_sort(sums, mid + 1, right)

        i = left
        j = mid + 1
        k = mid + 1
        l = mid + 1
        cache = []

        while i <= mid:
            while k <= right and sums[k] - sums[i] < lower:
                k += 1
            while l <= right and sums[l] - sums[i] <= upper:
                l += 1
            count += l - k

            while j <= right and sums[j] < sums[i]:
                cache.append(sums[j])
                j += 1

            cache.append(sums[i])
            i += 1

        sums[left:left + len(cache)] = cache
        sums[j:right+1] = sums[j:right+1]  #Correct for leftover elements from other half

        return count

    return merge_sort(prefix_sums, 0, n)
	```