Range Sum of Sorted Subarray Sums

Range Sum of Sorted Subarray Sums - Problem

Array Two Pointers Binary Search Sorting Prefix Sum Medium

You are given an array nums consisting of n positive integers. You need to compute the sum of all non-empty continuous subarrays from the array and then sort them in non-decreasing order, creating a new array of n * (n + 1) / 2 numbers.

Return the sum of the numbers from index left to index right (indexed from 1), inclusive, in the new array. Since the answer can be a huge number, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 13

💡 Note: All subarray sums: [1]=1, [2]=2, [3]=3, [4]=4, [1,2]=3, [2,3]=5, [3,4]=7, [1,2,3]=6, [2,3,4]=9, [1,2,3,4]=10. Sorted: [1,2,3,3,4,5,6,7,9,10]. Sum from index 1 to 5: 1+2+3+3+4 = 13

Example 2 — Small Array

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

› Output: 6

💡 Note: Subarray sums: [1]=1, [2]=2, [1,2]=3. Sorted: [1,2,3]. Sum from index 1 to 3: 1+2+3 = 6

Example 3 — Single Range

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

› Output: 50

💡 Note: All 10 subarray sums: [1,2,3,3,4,5,6,7,9,10]. Sum of all elements: 1+2+3+3+4+5+6+7+9+10 = 50

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 100
1 ≤ left ≤ right ≤ n * (n + 1) / 2

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to generate all possible subarray sums, sort them, then sum the specified range. The brute force approach generates all O(n²) subarray sums and sorts them in O(n² log n). The priority queue approach is more memory efficient for small ranges. Best approach depends on the size of the range vs array size. Time: O(n² log n), Space: O(n²)

Common Approaches

✓ Generate All Subarray Sums

⏱️ Time: O(n² log n) Space: O(n²)

Generate all n*(n+1)/2 possible subarray sums using nested loops, store them in an array, sort the array, then sum elements from index left-1 to right-1 (converting to 0-indexed).

Priority Queue Approach

⏱️ Time: O(right × log(right)) Space: O(right)

Instead of generating all subarray sums, use a priority queue (min-heap) to generate only the smallest k sums where k = right. This avoids storing all O(n²) sums in memory and can be more efficient for small ranges.

Generate All Subarray Sums — Algorithm Steps

Generate all subarray sums using nested loops
Sort the sums array
Sum elements from left-1 to right-1 indices
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Sums

Create all subarray sums using nested loops

Sort

Sort all sums in ascending order

Sum Range

Sum elements from left to right indices

Code -

solution.c — C

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

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

int solution(int* nums, int numsSize, int left, int right) {
    const int MOD = 1000000007;
    int totalSums = numsSize * (numsSize + 1) / 2;
    long long* sums = (long long*)malloc(totalSums * sizeof(long long));
    int idx = 0;
    
    // Generate all subarray sums
    for (int i = 0; i < numsSize; i++) {
        long long currentSum = 0;
        for (int j = i; j < numsSize; j++) {
            currentSum += nums[j];
            sums[idx++] = currentSum;
        }
    }
    
    // Sort the sums
    qsort(sums, totalSums, sizeof(long long), compare);
    
    // Sum elements from left-1 to right-1 (convert to 0-indexed)
    long long result = 0;
    for (int i = left - 1; i < right; i++) {
        result = (result + sums[i]) % MOD;
    }
    
    free(sums);
    return (int)result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove trailing newline
    line[strcspn(line, "\n")] = 0;
    
    // Parse array - skip opening bracket
    int nums[1000];
    int numsSize = 0;
    char* ptr = line + 1; // Skip '['
    char* token = strtok(ptr, ",");
    while (token != NULL) {
        // Remove any brackets or whitespace
        while (*token == ' ' || *token == '[') token++;
        if (*token == ']') break;
        
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",");
    }
    
    int left, right;
    scanf("%d %d", &left, &right);
    
    int result = solution(nums, numsSize, left, right);
    printf("%d\n", result);
    
    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

⚡ Linearithmic

Space Complexity

O(n²)

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

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

742 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

Generate All Subarray Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler