Range Addition - Practice Coding Problems

Range Addition - Problem

Imagine you're a game developer working on a score multiplier system. You start with an array of zeros representing base scores, and you need to apply multiple range updates to boost scores in specific segments.

Given an integer length and an array updates where updates[i] = [startIdx, endIdx, inc], you have an array arr of length length with all zeros initially.

For each update operation, you need to increment all elements from arr[startIdx] to arr[endIdx] (inclusive) by inc.

Goal: Return the final array after applying all updates efficiently.

Example: If length = 5 and updates = [[1,3,2],[2,4,3],[0,2,-2]], the final array should be [-2, 0, 3, 5, 3].

Input & Output

example_1.py — 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.py — Single Update

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

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

💡 Note: Only one update operation adds 6 to positions 2, 3, and 4. All other positions remain 0.

example_3.py — Empty Updates

$ Input: length = 3, updates = []

› Output: [0,0,0]

💡 Note: No updates applied, so the array remains all zeros as initialized.

Visualization

Tap to expand

Understanding the Visualization

Mark Passenger Movements

Instead of tracking weight at every floor, just mark when passengers get ON (+weight) and get OFF (-weight)

One Sweep Calculation

Make one pass through all floors, keeping a running total of weight changes

Efficient Result

This gives us the weight at each floor without processing every floor for every group

Key Takeaway

🎯 Key Insight: Transform expensive range operations into cheap boundary markers + one sweep. This is the essence of difference arrays!

Time & Space Complexity

Time Complexity

⏱️

O(k + n)

Where k is the number of updates and n is the array length. We process each update in O(1) and then do one O(n) prefix sum pass

✓ Linear Growth

Space Complexity

O(n)

We need the difference array of size n (or n+1 to handle end+1 safely)

⚡ Linearithmic Space

Constraints

1 ≤ length ≤ 10⁵
0 ≤ updates.length ≤ 10⁴
0 ≤ startIdx ≤ endIdx < length
-1000 ≤ inc ≤ 1000

Asked in

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

The optimal solution uses a difference array technique to transform range updates into point updates. Instead of updating entire ranges, we mark boundaries: add the increment at the start index and subtract it at end+1 index. Then we compute the prefix sum to propagate these boundary changes across the entire array, achieving O(k + n) time complexity where k is the number of updates.

Common Approaches

Approach	Time	Space	Notes
✓ Difference Array (Optimal)	O(k + n)	O(n)	Use difference array technique to mark range boundaries, then compute prefix sum
Brute Force (Nested Loops)	O(n × k)	O(1)	Apply each update by iterating through the entire range

Difference Array (Optimal) — Algorithm Steps

Create a difference array initialized with zeros
For each update [start, end, inc]: add inc to diff[start] and subtract inc from diff[end+1]
Compute prefix sum of difference array to get final result
The prefix sum represents the cumulative effect of all range updates

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Difference Array

Initialize diff array: [0,0,0,0,0,0]

Mark Boundaries

For each update, mark start (+inc) and end+1 (-inc)

Process Updates

diff becomes [−2,2,1,−2,−3,0] after all updates

Compute Prefix Sum

Running sum gives final result: [−2,0,3,5,3]

Code -

solution.c — C

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

int* getModifiedArray(int length, int** updates, int updatesSize, int* returnSize) {
    // Create difference array with extra space
    int* diff = (int*)calloc(length + 1, sizeof(int));
    
    // Mark boundaries of each range update
    for (int i = 0; i < updatesSize; i++) {
        int startIdx = updates[i][0];
        int endIdx = updates[i][1];
        int inc = updates[i][2];
        
        diff[startIdx] += inc;
        diff[endIdx + 1] -= inc;
    }
    
    // Compute prefix sum to get final result
    int* result = (int*)malloc(length * sizeof(int));
    int runningSum = 0;
    for (int i = 0; i < length; i++) {
        runningSum += diff[i];
        result[i] = runningSum;
    }
    
    free(diff);
    *returnSize = length;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(k + n)

Where k is the number of updates and n is the array length. We process each update in O(1) and then do one O(n) prefix sum pass

✓ Linear Growth

Space Complexity

O(n)

We need the difference array of size n (or n+1 to handle end+1 safely)

⚡ Linearithmic Space

Constraints

1 ≤ length ≤ 10⁵
0 ≤ updates.length ≤ 10⁴
0 ≤ startIdx ≤ endIdx < length
-1000 ≤ inc ≤ 1000

87.3K Views

Medium Frequency

~15 min Avg. Time

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

Difference Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler