Amount of New Area Painted Each Day - Practice Coding Problems

Amount of New Area Painted Each Day - Problem

Imagine you're a painter working on a long, horizontal canvas that stretches across a number line. Each day, you receive instructions to paint a specific section of this canvas, represented by intervals [start, end].

The challenge is that painting over already painted areas creates an uneven, messy result. You only want to paint each position on the canvas at most once.

Given a 2D array paint where paint[i] = [start_i, end_i] represents the section you need to paint on day i, return an array showing how much new area you actually painted each day (excluding areas that were already painted on previous days).

Goal: Calculate the amount of fresh, unpainted area covered each day.
Input: Array of painting intervals for each day
Output: Array showing new area painted each day

Input & Output

example_1.py — Basic Example

$ Input: paint = [[1,4],[4,7],[1,3]]

› Output: [3,3,0]

💡 Note: Day 1: Paint [1,4) - all new area, paint 3 units. Day 2: Paint [4,7) - all new area, paint 3 units. Day 3: Paint [1,3) - already painted on day 1, paint 0 new units.

example_2.py — Overlapping Intervals

$ Input: paint = [[1,5],[2,4]]

› Output: [4,0]

💡 Note: Day 1: Paint [1,5) - paint 4 units. Day 2: Paint [2,4) - this range is completely within [1,5) which was already painted, so 0 new units.

example_3.py — Partial Overlaps

$ Input: paint = [[1,4],[2,6],[3,8]]

› Output: [3,2,2]

💡 Note: Day 1: Paint [1,4) → 3 units. Day 2: Paint [2,6) → [2,4) already painted, only [4,6) is new → 2 units. Day 3: Paint [3,8) → [3,6) already painted, only [6,8) is new → 2 units.

Constraints

1 ≤ paint.length ≤ 10⁵
paint[i].length == 2
0 ≤ start_i < end_i ≤ 5 × 10⁴
Each interval represents [start, end) - start inclusive, end exclusive

Visualization

Tap to expand

Understanding the Visualization

Day 1: Paint [1,4)

Paint positions 1, 2, 3 on empty canvas → 3 new units

Day 2: Paint [4,7)

Paint positions 4, 5, 6 on canvas → 3 new units (no overlap)

Day 3: Paint [1,3)

Attempt to paint positions 1, 2 → 0 new units (already painted)

Key Takeaway

🎯 Key Insight: Use coordinate compression to track only the segment boundaries rather than individual positions, reducing time complexity from O(sum of ranges) to O(n log n).

Asked in

G Google 85 a Amazon 72 ⊞ Microsoft 58 f Meta 43

The optimal approach uses coordinate compression to reduce the problem space to only the relevant boundary points, then tracks painted segments efficiently. This reduces the complexity from O(sum of ranges) to O(n log n) where n is the number of intervals. Key insight: instead of tracking every position individually, we only need to track the segments between consecutive boundary points.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Range Tracking)	O(C)	O(C)	Track all painted positions and check each new position individually
Coordinate Compression + Union-Find	O(n²α(n))	O(n)	Compress coordinates and use Union-Find to efficiently merge intervals
Segment Tree Approach	O(n log n)	O(n)	Use segment tree with coordinate compression for efficient range updates

Brute Force (Range Tracking) — Algorithm Steps

Initialize a set to track all painted positions
For each day's painting task [start, end]:
Count how many positions in [start, end) are not yet painted
Add all positions in [start, end) to the painted set
Record the count of newly painted positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Day 1: Paint [1,4)

Check positions 1,2,3 - all new, paint 3 units

Day 2: Paint [4,7)

Check positions 4,5,6 - all new, paint 3 units

Day 3: Paint [1,3)

Check positions 1,2 - already painted, paint 0 units

Code -

solution.c — C

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

#define MAX_COORD 50000

int* amountPainted(int** paint, int paintSize, int* returnSize) {
    bool painted[MAX_COORD] = {false};
    int* result = (int*)malloc(paintSize * sizeof(int));
    *returnSize = paintSize;
    
    for (int i = 0; i < paintSize; i++) {
        int start = paint[i][0], end = paint[i][1];
        int newPainted = 0;
        
        for (int pos = start; pos < end; pos++) {
            if (!painted[pos]) {
                newPainted++;
                painted[pos] = true;
            }
        }
        result[i] = newPainted;
    }
    
    return result;
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C)

Where C is the sum of all range lengths, potentially up to n * (max_coordinate)

✓ Linear Growth

Space Complexity

O(C)

Need to store all painted positions in worst case

✓ Linear Space

43.7K Views

Medium-High Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Range Tracking) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler