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, 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

    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)