Range Sum Query - Mutable - Practice Coding Problems

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.

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

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.

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
✓ 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)	O(n) per query, O(1) per update	O(1)	Store array directly, recalculate sum for each range query

Segment Tree (Optimal) — Algorithm Steps

Build a complete binary tree with 4*n nodes
Each leaf stores an array element, internal nodes store sums
For updates: modify leaf and propagate changes up the tree
For queries: combine relevant node values to get range sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Tree

Create binary tree with range sums

Query Range

Combine relevant nodes for range sum

Update Value

Modify leaf and propagate changes upward

Code -

solution.c — C

typedef struct {
    int* tree;
    int n;
} NumArray;

void build(int* nums, int* tree, int node, int start, int end) {
    if (start == end) {
        tree[node] = nums[start];
    } else {
        int mid = (start + end) / 2;
        build(nums, tree, 2*node+1, start, mid);
        build(nums, tree, 2*node+2, mid+1, end);
        tree[node] = tree[2*node+1] + tree[2*node+2];
    }
}

NumArray* numArrayCreate(int* nums, int numsSize) {
    NumArray* obj = (NumArray*)malloc(sizeof(NumArray));
    obj->n = numsSize;
    obj->tree = (int*)calloc(4 * numsSize, sizeof(int));
    if (numsSize > 0) {
        build(nums, obj->tree, 0, 0, numsSize - 1);
    }
    return obj;
}

void updateHelper(int* tree, int node, int start, int end, int idx, int val) {
    if (start == end) {
        tree[node] = val;
    } else {
        int mid = (start + end) / 2;
        if (idx <= mid) {
            updateHelper(tree, 2*node+1, start, mid, idx, val);
        } else {
            updateHelper(tree, 2*node+2, mid+1, end, idx, val);
        }
        tree[node] = tree[2*node+1] + tree[2*node+2];
    }
}

void numArrayUpdate(NumArray* obj, int index, int val) {
    updateHelper(obj->tree, 0, 0, obj->n-1, index, val);
}

int query(int* tree, int node, int start, int end, int l, int r) {
    if (r < start || end < l) return 0;
    if (l <= start && end <= r) return tree[node];
    
    int mid = (start + end) / 2;
    return query(tree, 2*node+1, start, mid, l, r) + 
           query(tree, 2*node+2, mid+1, end, l, r);
}

int numArraySumRange(NumArray* obj, int left, int right) {
    return query(obj->tree, 0, 0, obj->n-1, left, right);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Tree height is log n, so both update and query operations traverse at most log n nodes

⚡ Linearithmic

Space Complexity

O(n)

Segment tree requires approximately 4n space to handle all possible ranges

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Segment Tree (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler