Range Sum Query - Immutable

Range Sum Query - Immutable - Problem

Given an integer array nums, handle multiple queries of the following type:

Calculate the sum of the elements of nums between indices left and right inclusive where left <= right.

Implement the NumArray class:

NumArray(int[] nums) Initializes the object with the integer array nums.
int sumRange(int left, int right) Returns the sum of the elements of nums between indices left and right inclusive.

Input & Output

Example 1 — Basic Range Queries

$ Input: nums = [-2,0,3,-5,2,-1], operations = [["sumRange",0,2],["sumRange",2,5],["sumRange",0,5]]

› Output: [1,-1,-3]

💡 Note: sumRange(0,2) = (-2) + 0 + 3 = 1, sumRange(2,5) = 3 + (-5) + 2 + (-1) = -1, sumRange(0,5) = (-2) + 0 + 3 + (-5) + 2 + (-1) = -3

Example 2 — Single Element Range

$ Input: nums = [1,3,5], operations = [["sumRange",1,1],["sumRange",0,2]]

› Output: [3,9]

💡 Note: sumRange(1,1) = nums[1] = 3, sumRange(0,2) = 1 + 3 + 5 = 9

Example 3 — Full Array Range

$ Input: nums = [5,-3,5], operations = [["sumRange",0,0],["sumRange",1,2],["sumRange",0,2]]

› Output: [5,2,7]

💡 Note: sumRange(0,0) = 5, sumRange(1,2) = -3 + 5 = 2, sumRange(0,2) = 5 + (-3) + 5 = 7

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵
0 ≤ left ≤ right < nums.length
At most 10⁴ calls to sumRange

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to precompute prefix sums during initialization to enable O(1) range queries. Best approach is Prefix Sum with O(n) preprocessing and O(1) per query. Time: O(1) per query, Space: O(n)

Common Approaches

✓ Brute Force - Calculate Sum Each Time

⏱️ Time: O(n) Space: O(1)

Store the original array and for each sumRange query, loop through indices from left to right, adding each element to get the sum. Simple but inefficient for multiple queries.

Prefix Sum - Precompute Cumulative Sums

⏱️ Time: O(1) Space: O(n)

Precompute cumulative sums in constructor. For any range [left, right], the sum equals prefixSum[right+1] - prefixSum[left]. This trades initialization time for very fast queries.

Brute Force - Calculate Sum Each Time — Algorithm Steps

Store the input array
For each sumRange query, initialize sum to 0
Loop from left to right index, adding each nums[i] to sum
Return the calculated sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Array

Keep original array [-2,0,3,-5,2,-1]

Query sumRange(0,2)

Loop i=0 to 2: -2+0+3 = 1

Result

Return calculated sum

Code -

solution.c — C

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

typedef struct {
    int* nums;
    int size;
} NumArray;

int sumRange(NumArray* obj, int left, int right) {
    int total = 0;
    for (int i = left; i <= right; i++) {
        total += obj->nums[i];
    }
    return total;
}

int* solution(int* nums, int numsSize, int** operations, int operationsSize, int* returnSize) {
    NumArray numArray = {nums, numsSize};
    int* results = malloc(operationsSize * sizeof(int));
    int resultCount = 0;
    
    for (int i = 0; i < operationsSize; i++) {
        int left = operations[i][0];
        int right = operations[i][1];
        results[resultCount++] = sumRange(&numArray, left, right);
    }
    
    *returnSize = resultCount;
    return results;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse nums array
    int nums[10000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    
    // Parse operations - simplified parsing for sumRange operations
    int operations[1000][2];
    int* opPtrs[1000];
    int operationsSize = 0;
    
    char* pos = line;
    while ((pos = strstr(pos, "sumRange")) != NULL) {
        pos = strchr(pos, ',') + 1;
        operations[operationsSize][0] = atoi(pos);
        pos = strchr(pos, ',') + 1;
        operations[operationsSize][1] = atoi(pos);
        opPtrs[operationsSize] = operations[operationsSize];
        operationsSize++;
        pos++;
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, opPtrs, operationsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each sumRange query loops through at most n elements

✓ Linear Growth

Space Complexity

O(1)

Only storing the original array, no extra data structures

✓ Linear Space

285.0K Views

Medium Frequency

~15 min Avg. Time

3.2K 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 - Calculate Sum Each Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler