Count of Range Sum - Practice Coding Problems

Count of Range Sum - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

Count of Range Sum is a challenging problem that asks you to find how many subarray sums fall within a given range.

You're given an integer array nums and two integers lower and upper. Your task is to count how many range sums lie in the interval [lower, upper] inclusive.

A range sum S(i, j) is defined as the sum of elements from index i to index j (where i ≤ j). For example, in array [1, 2, 3], the range sums are: 1, 2, 3, 1+2=3, 2+3=5, and 1+2+3=6.

Goal: Return the total count of range sums that satisfy lower ≤ range_sum ≤ upper.

Input & Output

example_1.py — Basic Case

$ Input: nums = [-2, 5, -1], lower = -2, upper = 2

› Output: 3

💡 Note: The valid range sums are: [-2] = -2, [-1] = -1, and [-2, 5, -1] = 2. All three fall within the range [-2, 2].

example_2.py — All Positive

$ Input: nums = [1, 2, 3], lower = 3, upper = 5

› Output: 2

💡 Note: Valid range sums are: [3] = 3 and [1, 2] = 3. Both equal 3 which is in range [3, 5]. [2, 3] = 5 is also valid.

example_3.py — Single Element

$ Input: nums = [0], lower = 0, upper = 0

› Output: 1

💡 Note: Only one range sum possible: [0] = 0, which exactly matches the range [0, 0].

Visualization

Tap to expand

Understanding the Visualization

Convert to prefix sums

Transform the problem into cumulative sums

Use divide and conquer

Split array and count cross-boundary valid ranges

Merge and count

Combine results while maintaining sorted order

Key Takeaway

🎯 Key Insight: Convert range sum counting to prefix sum differences, then use efficient sorting-based algorithms to count valid pairs in O(n log n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For each of n positions, we do binary search (log n) and insertion (O(n)) in sorted list

⚠ Quadratic Growth

Space Complexity

O(n)

Space for prefix sums and sorted list of previous prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
-10⁵ ≤ lower ≤ upper ≤ 10⁵
Watch out for integer overflow - use long long in C++ or long in Java

Asked in

G Google 45 a Amazon 32 ⊞ Microsoft 28 f Meta 22

The optimal approach uses merge sort with divide and conquer to achieve O(n log n) time complexity. Convert to prefix sums, then during merge sort, count valid ranges by leveraging the sorted property. The key insight is that range sum problems can be transformed into prefix sum difference problems.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum + Binary Search	O(n² log n)	O(n)	Use prefix sums and binary search on sorted prefix array
Brute Force (All Pairs)	O(n³)	O(1)	Check every possible subarray and count those with sums in range

Prefix Sum + Binary Search — Algorithm Steps

Calculate prefix sums for the array
For each position, we need prefix[j] - prefix[i-1] in [lower, upper]
This means prefix[i-1] should be in [prefix[j] - upper, prefix[j] - lower]
Use binary search on sorted previous prefix sums to count valid ranges
Add current prefix sum to sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate prefix sum

For each position, calculate running prefix sum

Binary search range

Find how many previous prefix sums create valid range

Insert and continue

Add current prefix sum to sorted list

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int binarySearchLeft(long long* arr, int size, long long target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] < target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int binarySearchRight(long long* arr, int size, long long target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int countRangeSum(int* nums, int numsSize, int lower, int upper) {
    long long* sortedPrefixSums = (long long*)malloc(sizeof(long long) * (numsSize + 1));
    sortedPrefixSums[0] = 0;
    int sortedSize = 1;
    
    long long prefixSum = 0;
    int totalCount = 0;
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        
        long long targetLower = prefixSum - upper;
        long long targetUpper = prefixSum - lower;
        
        int leftIdx = binarySearchLeft(sortedPrefixSums, sortedSize, targetLower);
        int rightIdx = binarySearchRight(sortedPrefixSums, sortedSize, targetUpper);
        totalCount += rightIdx - leftIdx;
        
        // Insert prefixSum in sorted order
        int insertPos = binarySearchLeft(sortedPrefixSums, sortedSize, prefixSum);
        for (int j = sortedSize; j > insertPos; j--) {
            sortedPrefixSums[j] = sortedPrefixSums[j-1];
        }
        sortedPrefixSums[insertPos] = prefixSum;
        sortedSize++;
    }
    
    free(sortedPrefixSums);
    return totalCount;
}

int main() {
    int nums[] = {-2, 5, -1};
    int lower = -2, upper = 2;
    printf("%d\n", countRangeSum(nums, 3, lower, upper));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

For each of n positions, we do binary search (log n) and insertion (O(n)) in sorted list

⚠ Quadratic Growth

Space Complexity

O(n)

Space for prefix sums and sorted list of previous prefix sums

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
-10⁵ ≤ lower ≤ upper ≤ 10⁵
Watch out for integer overflow - use long long in C++ or long in Java

52.0K Views

Medium Frequency

~35 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Prefix Sum + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler