Codestin Search App

Range Sum Query - Mutable - Problem

Range Sum Query - Mutable challenges you to build an efficient data structure that handles two critical operations on an array: updates and range sum queries.

You're given an integer array nums and need to implement the NumArray class that supports:
• Update Operation: Change the value at any index
• Range Sum Query: Calculate the sum of elements between any two indices (inclusive)

The key challenge is handling multiple operations efficiently. A naive approach might recalculate sums from scratch each time, but with potentially thousands of operations, you need something faster.

Example:
NumArray numArray = new NumArray([1, 3, 5]);
numArray.sumRange(0, 2); // Returns 9 (1+3+5)
numArray.update(1, 2); // Array becomes [1, 2, 5]
numArray.sumRange(0, 2); // Returns 8 (1+2+5)

Input & Output

example_1.py — Basic Operations

$ Input: NumArray([1, 3, 5]) sumRange(0, 2) update(1, 2) sumRange(0, 2)

› Output: 9 8

💡 Note: Initial array [1,3,5] has sum 9 for range [0,2]. After updating index 1 to value 2, array becomes [1,2,5] with sum 8.

example_2.py — Single Element

$ Input: NumArray([7]) sumRange(0, 0) update(0, 3) sumRange(0, 0)

› Output: 7 3

💡 Note: Single element array: sum of range [0,0] is just the element itself. After update, the value changes from 7 to 3.

example_3.py — Multiple Updates

$ Input: NumArray([1, 2, 3, 4, 5]) sumRange(0, 4) update(2, 10) sumRange(0, 4) update(4, 1) sumRange(0, 4)

› Output: 15 22 18

💡 Note: Original sum: 1+2+3+4+5=15. After update(2,10): 1+2+10+4+5=22. After update(4,1): 1+2+10+4+1=18.

Visualization

Tap to expand

Understanding the Visualization

Build Tree Structure

Create binary tree with each node storing sum of its range

Handle Range Query

Traverse tree to find nodes that cover the query range optimally

Process Update

Modify leaf node and propagate changes up to maintain tree properties

Key Takeaway

🎯 Key Insight: Segment Trees achieve optimal O(log n) performance by hierarchically organizing range information, making both updates and queries logarithmic in the array size.

Time & Space Complexity

Time Complexity

⏱️

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

Each sumRange call must iterate through up to n elements, while updates are constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the original array, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-100 ≤ nums[i] ≤ 100
0 ≤ index < nums.length
-100 ≤ val ≤ 100
0 ≤ left ≤ right < nums.length
At most 3 × 10⁴ calls will be made to update and sumRange

Asked in

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

The optimal solution uses a Segment Tree data structure that provides O(log n) time complexity for both update and range sum operations. The tree stores range sums in internal nodes, allowing efficient queries by combining relevant subtrees, while updates propagate changes from leaves to root.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Array Access)	O(n) per query, O(1) per update	O(1)	Store array directly, recalculate sum for each range query
Segment Tree (Optimal)	O(log n)	O(n)	Build a binary tree where each node stores the sum of a range

Brute Force (Direct Array Access) — Algorithm Steps

Store the input array directly
For updates: directly modify array[index] = val
For range queries: loop from left to right and sum all elements
Return the accumulated sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Array: [1, 3, 5, 2, 6] stored directly

Range Query

For sumRange(1, 3): scan indices 1→2→3

Calculate Sum

Sum = 3 + 5 + 2 = 10

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));
    obj->size = numsSize;
    for (int i = 0; i < numsSize; i++) {
        obj->nums[i] = nums[i];
    }
    return obj;
}

void numArrayUpdate(NumArray* obj, int index, int val) {
    obj->nums[index] = val;
}

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

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

Time & Space Complexity

Time Complexity

⏱️

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

Each sumRange call must iterate through up to n elements, while updates are constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the original array, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-100 ≤ nums[i] ≤ 100
0 ≤ index < nums.length
-100 ≤ val ≤ 100
0 ≤ left ≤ right < nums.length
At most 3 × 10⁴ calls will be made to update and sumRange

96.5K Views

High Frequency

~25 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

Brute Force (Direct Array Access) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler