Range Sum of Sorted Subarray Sums - Practice Coding Problems

Range Sum of Sorted Subarray Sums - Problem

Array Two Pointers Binary Search Sorting Prefix Sum Medium

Range Sum of Sorted Subarray Sums

Imagine you have an array of positive integers, and you want to explore all possible continuous subarrays within it. Your task is to compute the sum of every possible subarray, sort these sums in ascending order, and then find the sum of elements within a specific range.

Here's the process:
1. Generate all subarray sums: For an array of size n, there are exactly n × (n + 1) / 2 continuous subarrays
2. Sort the sums: Arrange all subarray sums in non-decreasing order
3. Range sum: Calculate the sum from index left to right (1-indexed) in the sorted array

Goal: Return the range sum modulo 10⁹ + 7 since the answer can be very large.

Example: For array [1,2,3,4], subarrays are [1],[2],[3],[4],[1,2],[2,3],[3,4],[1,2,3],[2,3,4],[1,2,3,4] with sums [1,2,3,4,3,5,7,6,9,10]. After sorting: [1,2,3,3,4,5,6,7,9,10].

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3,4], n = 4, left = 1, right = 5

› Output: 13

💡 Note: All subarray sums are [1,2,3,4,3,5,7,6,9,10]. After sorting: [1,2,3,3,4,5,6,7,9,10]. Sum of 1st to 5th elements: 1+2+3+3+4 = 13.

example_2.py — Full Range

$ Input: nums = [1,2,3,4], n = 4, left = 3, right = 4

› Output: 6

💡 Note: From sorted subarray sums [1,2,3,3,4,5,6,7,9,10], elements at positions 3-4 are [3,3]. Sum = 3+3 = 6.

example_3.py — Single Element Array

$ Input: nums = [1], n = 1, left = 1, right = 1

› Output: 1

💡 Note: Only one subarray [1] with sum 1. The range [1,1] contains just this element, so answer is 1.

Constraints

n == nums.length
1 ≤ n ≤ 1000
1 ≤ nums[i] ≤ 100
1 ≤ left ≤ right ≤ n × (n + 1) / 2
Answer must be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Generate All Subarrays

Create every possible continuous subarray from the original array

Calculate Sums

Compute the sum for each subarray we generated

Sort by Value

Arrange all subarray sums in ascending order

Extract Range

Sum the elements from position left to right in sorted array

Key Takeaway

🎯 Key Insight: While the brute force approach directly implements the problem description, binary search optimization can significantly reduce space complexity from O(n²) to O(1) by cleverly counting subarray sums without storing them all.

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 6 f Meta 4

This problem requires generating all subarray sums, sorting them, and finding a range sum. The brute force approach generates all O(n²) subarray sums explicitly, sorts them in O(n²log n) time, then computes the range sum. For better space efficiency, the binary search approach avoids storing all sums by using binary search with sliding window counting, achieving O(1) space complexity while maintaining similar time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Sums)	O(n²log n)	O(n²)	Generate all subarray sums, sort them, then calculate range sum
Binary Search + Sliding Window (Optimized)	O(n² log(sum))	O(1)	Use binary search to find sums within range efficiently without generating all sums

Brute Force (Generate All Sums) — Algorithm Steps

Use nested loops to generate all subarray sums (i to j for all valid i, j)
Store all sums in an array
Sort the array in non-decreasing order
Sum elements from index left-1 to right-1 (converting to 0-indexed)
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible continuous subarrays

Calculate Sums

Compute sum for each subarray

Sort Results

Sort all sums in ascending order

Range Sum

Sum elements in specified range

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    long long diff = *(long long*)a - *(long long*)b;
    return (diff > 0) - (diff < 0);
}

int rangeSum(int* nums, int n, int left, int right) {
    const int MOD = 1000000007;
    
    // Generate all subarray sums
    long long* subarraySums = (long long*)malloc(n * (n + 1) / 2 * sizeof(long long));
    int idx = 0;
    
    for (int i = 0; i < n; i++) {
        long long currentSum = 0;
        for (int j = i; j < n; j++) {
            currentSum += nums[j];
            subarraySums[idx++] = currentSum;
        }
    }
    
    // Sort the sums
    qsort(subarraySums, idx, sizeof(long long), compare);
    
    // Calculate range sum
    long long result = 0;
    for (int i = left - 1; i < right; i++) {
        result = (result + subarraySums[i]) % MOD;
    }
    
    free(subarraySums);
    return (int)result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char *token = strtok(line, " \n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    int actualN, left, right;
    scanf("%d %d %d", &actualN, &left, &right);
    
    printf("%d\n", rangeSum(nums, actualN, left, right));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²log n)

O(n²) to generate all subarray sums + O(n²log n) to sort them

⚠ Quadratic Growth

Space Complexity

O(n²)

Need to store n*(n+1)/2 subarray sums

⚠ Quadratic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

891 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate All Sums) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler