Range Sum Query - Immutable - Practice Coding Problems

Range Sum Query - Immutable - Problem

Imagine you're working with a fixed dataset and need to efficiently answer multiple range sum queries. You're given an integer array nums and must handle numerous queries asking for the sum of elements between specific indices.

Your task: Implement the NumArray class that can:

NumArray(int[] nums) - Initialize with the integer array
int sumRange(int left, int right) - Return the sum of elements from index left to right (inclusive)

Key Challenge: Since there will be many queries, you need to optimize for query time rather than just solving it once. A naive approach of summing elements for each query would be too slow for large datasets with frequent queries.

Example: Given nums = [-2, 0, 3, -5, 2, -1]
• sumRange(0, 2) returns 1 (sum of -2, 0, 3)
• sumRange(2, 5) returns -1 (sum of 3, -5, 2, -1)

Input & Output

example_1.py — Basic Range Queries

$ Input: nums = [-2, 0, 3, -5, 2, -1]\nQueries: 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) = sum of entire array = -3

example_2.py — Single Element Range

$ Input: nums = [1, 2, 3, 4, 5]\nQueries: sumRange(2, 2), sumRange(0, 0)

› Output: 3, 1

💡 Note: When left equals right, we return the single element at that index. sumRange(2, 2) returns nums[2] = 3, sumRange(0, 0) returns nums[0] = 1

example_3.py — Full Array Range

$ Input: nums = [5, -3, 5]\nQueries: sumRange(0, 2)

› Output: 7

💡 Note: sumRange(0, 2) covers the entire array: 5 + (-3) + 5 = 7. This tests the boundary case where we query the complete range

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Create a ledger where each entry shows total value from first shelf to current position

Query Arrives

Customer asks: 'What's the total value from shelf 3 to shelf 7?'

Quick Lookup

Look up total-to-shelf-7 minus total-to-shelf-2 in the ledger

Instant Answer

Provide answer immediately without walking through shelves

Key Takeaway

🎯 Key Insight: Prefix sums transform multiple expensive O(n) range queries into instant O(1) calculations through smart preprocessing

Time & Space Complexity

Time Complexity

⏱️

O(1) per query, O(n) initialization

After O(n) preprocessing, each query is answered in constant time using simple subtraction

✓ Linear Growth

Space Complexity

O(n)

Additional array to store prefix sums, same size as input array

⚡ Linearithmic Space

Constraints

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

Asked in

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

The optimal solution uses prefix sums to preprocess the array during initialization. By storing cumulative sums, any range query becomes a simple O(1) subtraction: prefix[right+1] - prefix[left]. This transforms expensive per-query computations into instant lookups, perfect for scenarios with multiple queries on immutable data.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Approach (Sum on Each Query)	O(n) per query	O(1)	Sum elements from left to right for each query
Prefix Sum (Optimal)	O(1) per query, O(n) initialization	O(n)	Precompute cumulative sums to answer queries in O(1) time

Naive Approach (Sum on Each Query) — Algorithm Steps

Store the input array in the constructor
For each sumRange(left, right) call, initialize sum = 0
Loop from left to right index (inclusive)
Add each element to the sum
Return the total sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Query received

sumRange(1, 4) called - need to sum indices 1 through 4

Start iteration

Begin at left index, initialize sum = 0

Add each element

Visit each index from left to right, adding to sum

Return result

After visiting all indices in range, return total sum

Code -

solution.c — C

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

NumArray* numArrayCreate(int* nums, int numsSize) {
    NumArray* obj = (NumArray*)malloc(sizeof(NumArray));
    obj->nums = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        obj->nums[i] = nums[i];
    }
    obj->size = numsSize;
    return obj;
}

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

void numArrayFree(NumArray* obj) {
    free(obj->nums);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n) per query

Each sumRange call needs to iterate through up to n elements in worst case

✓ Linear Growth

Space Complexity

O(1)

Only storing the original array, no additional space for preprocessing

✓ Linear Space

Constraints

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

89.1K Views

High Frequency

~15 min Avg. Time

2.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

Naive Approach (Sum on Each Query) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler