Range Addition

Range Addition - Problem

You are given an integer length and an array updates where updates[i] = [startIdxi, endIdxi, inci].

You have an array arr of length length with all zeros, and you have some operations to apply on arr.

In the i-th operation, you should increment all the elements arr[startIdxi], arr[startIdxi + 1], ..., arr[endIdxi] by inci.

Return arr after applying all the updates.

Input & Output

Example 1 — Basic Range Updates

$ Input: length = 5, updates = [[1,3,2],[2,4,3],[0,2,-2]]

› Output: [-2,0,3,5,3]

💡 Note: Start with [0,0,0,0,0]. After [1,3,2]: [0,2,2,2,0]. After [2,4,3]: [0,2,5,5,3]. After [0,2,-2]: [-2,0,3,5,3].

Example 2 — Single Update

$ Input: length = 10, updates = [[2,4,6]]

› Output: [0,0,6,6,6,0,0,0,0,0]

💡 Note: Add 6 to indices 2,3,4. All other positions remain 0.

Example 3 — Overlapping Updates

$ Input: length = 3, updates = [[0,1,1],[1,2,1]]

› Output: [1,2,1]

💡 Note: First update: [1,1,0]. Second update adds to indices 1,2: [1,2,1].

Constraints

1 ≤ length ≤ 10⁵
0 ≤ updates.length ≤ 10⁴
0 ≤ startIdxi ≤ endIdxi < length
-1000 ≤ inci ≤ 1000

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to use a difference array to mark range boundaries instead of updating each element individually. The optimal approach uses difference array with prefix sum: mark start/end boundaries in O(1) per update, then compute final values with one pass. Time: O(n+m), Space: O(1).

Common Approaches

✓ Brute Force

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

For each update operation, iterate through the specified range and add the increment value to each element. This directly simulates the problem requirements.

Difference Array (Optimal)

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

Instead of updating each element in a range, mark the start and end boundaries of each update in a difference array. Then compute prefix sum to get final values efficiently.

Brute Force — Algorithm Steps

Step 1: Initialize array of zeros with given length
Step 2: For each update [start, end, inc], add inc to arr[start] through arr[end]
Step 3: Return the final array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with array of zeros

Apply Updates

For each update, modify range elements

Result

Final array after all updates

Code -

solution.c — C

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

int* solution(int length, int updates[][3], int updatesSize, int* returnSize) {
    int* arr = (int*)calloc(length, sizeof(int));
    *returnSize = length;
    
    for (int i = 0; i < updatesSize; i++) {
        int start = updates[i][0], end = updates[i][1], inc = updates[i][2];
        for (int j = start; j <= end; j++) {
            arr[j] += inc;
        }
    }
    return arr;
}

int main() {
    int length;
    scanf("%d", &length);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    // Simple parsing for [[a,b,c],[d,e,f],...] format
    int updates[1000][3];
    int updatesSize = 0;
    char* ptr = line + 1; // Skip first '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            updates[updatesSize][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            updates[updatesSize][1] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            updates[updatesSize][2] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            ptr++;
            updatesSize++;
        }
        if (*ptr == ',') ptr++;
    }
    
    int returnSize;
    int* result = solution(length, updates, updatesSize, &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 × m)

n is array length, m is number of updates. Each update can affect up to n elements

✓ Linear Growth

Space Complexity

O(1)

Only using the result array and loop variables

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler