Range Sum Query

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

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

✓ Brute Force (Direct Array Access)

⏱️ Time: O(n) per query, O(1) per update Space: O(1)

The simplest approach stores the array as-is. Updates are O(1), but each range sum query requires iterating through all elements in the range, making it inefficient for frequent queries.

Segment Tree (Optimal)

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

A Segment Tree is a binary tree where each node represents a range of the array and stores the sum of that range. The root represents the entire array, leaves represent individual elements. Both updates and queries run in O(log n) time.

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

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

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);
}

static int parseArray(const char* str, int start, int end, int* arr) {
    int count = 0;
    const char* ptr = str + start;
    const char* endPtr = str + end;
    
    // Skip whitespace
    while (ptr < endPtr && (*ptr == ' ' || *ptr == '\t')) ptr++;
    
    if (ptr >= endPtr) return 0; // empty array
    
    while (ptr < endPtr) {
        // Skip whitespace and commas
        while (ptr < endPtr && (*ptr == ' ' || *ptr == ',' || *ptr == '\t')) ptr++;
        
        if (ptr >= endPtr) break;
        
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            char* nextPtr;
            arr[count++] = (int)strtol(ptr, &nextPtr, 10);
            ptr = nextPtr;
        } else {
            ptr++;
        }
    }
    return count;
}

static void parseValues(const char* line, int operations[][10], int* opCounts, int numOps) {
    const char* ptr = line + 1; // Skip opening bracket
    int opIndex = 0;
    
    while (*ptr && opIndex < numOps) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\t')) ptr++;
        
        if (!*ptr) break;
        
        if (*ptr == '[') {
            int start = ptr - line + 1; // After opening bracket
            int bracketCount = 1;
            ptr++;
            
            // Find matching closing bracket
            while (*ptr && bracketCount > 0) {
                if (*ptr == '[') bracketCount++;
                else if (*ptr == ']') bracketCount--;
                ptr++;
            }
            
            int end = ptr - line - 1; // Before closing bracket
            
            // Parse this array
            static int tempArr[1000];
            int count = parseArray(line, start, end, tempArr);
            opCounts[opIndex] = count;
            for (int i = 0; i < count && i < 10; i++) {
                operations[opIndex][i] = tempArr[i];
            }
            
            opIndex++;
        } else {
            ptr++;
        }
    }
}

int main() {
    static char operationsLine[1000];
    static char valuesLine[10000];
    
    fgets(operationsLine, sizeof(operationsLine), stdin);
    fgets(valuesLine, sizeof(valuesLine), stdin);
    
    // Remove newlines
    operationsLine[strcspn(operationsLine, "\n")] = 0;
    valuesLine[strcspn(valuesLine, "\n")] = 0;
    
    // Parse operations
    static char operations[100][20];
    int numOps = 0;
    char* savePtr;
    char* token = strtok_r(operationsLine, ",", &savePtr);
    while (token && numOps < 100) {
        strcpy(operations[numOps], token);
        numOps++;
        token = strtok_r(NULL, ",", &savePtr);
    }
    
    // Parse values
    static int operationValues[100][10];
    static int opCounts[100];
    parseValues(valuesLine, operationValues, opCounts, numOps);
    
    // Execute operations
    static int results[100];
    static int resultTypes[100]; // 0 for null, 1 for int
    NumArray* numArray = NULL;
    
    for (int i = 0; i < numOps; i++) {
        if (strcmp(operations[i], "NumArray") == 0) {
            numArray = numArrayCreate(operationValues[i], opCounts[i]);
            resultTypes[i] = 0; // null
        } else if (strcmp(operations[i], "update") == 0) {
            numArrayUpdate(numArray, operationValues[i][0], operationValues[i][1]);
            resultTypes[i] = 0; // null
        } else if (strcmp(operations[i], "sumRange") == 0) {
            results[i] = numArraySumRange(numArray, operationValues[i][0], operationValues[i][1]);
            resultTypes[i] = 1; // int
        }
    }
    
    // Print results
    printf("[");
    for (int i = 0; i < numOps; i++) {
        if (i > 0) printf(", ");
        if (resultTypes[i] == 0) {
            printf("null");
        } else {
            printf("%d", results[i]);
        }
    }
    printf("]\n");
    
    if (numArray) numArrayFree(numArray);
    return 0;
}

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

⚡ Linearithmic

Space Complexity

O(1)

Only stores the original array, no additional data structures needed

⚡ 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

Brute Force (Direct Array Access) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler