Amount of New Area Painted Each Day - Problem

There is a long and thin painting that can be represented by a number line. You are given a 0-indexed 2D integer array paint of length n, where paint[i] = [start_i, end_i].

This means that on the i-th day you need to paint the area between start_i and end_i. Painting the same area multiple times will create an uneven painting so you only want to paint each area of the painting at most once.

Return an integer array worklog of length n, where worklog[i] is the amount of new area that you painted on the i-th day.

Input & Output

Example 1 — Basic Overlapping

$ Input: paint = [[1,4],[4,7],[5,8]]

› Output: [3,3,1]

💡 Note: Day 1: paint [1,4) → 3 new units. Day 2: paint [4,7) → 3 new units. Day 3: paint [5,8) → only position 7 is new (positions 5,6 already painted) → 1 new unit.

Example 2 — Complete Overlap

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

› Output: [3,0,2]

💡 Note: Day 1: paint [1,4) → 3 new units. Day 2: paint [2,3) → completely inside [1,4), 0 new units. Day 3: paint [4,6) → 2 new units.

Example 3 — No Overlap

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

› Output: [1,1,1]

💡 Note: All intervals are disjoint, each day paints exactly 1 new unit.

Constraints

1 ≤ paint.length ≤ 2 × 10⁴
paint[i].length == 2
0 ≤ start_i < end_i ≤ 5 × 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 12

The key insight is tracking painted areas efficiently to avoid redundant painting. The brute force approach uses a set to track every painted position. The optimized approach maintains intervals and merges overlaps. Best approach depends on range size vs. number of intervals. Time: O(n × r) brute force, O(n²) interval merging. Space: O(r) or O(n).

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force with Set Tracking

⏱️ Time: O(n × r) Space: O(r)

For each day, iterate through the range and add unpainted positions to a set. Count how many new positions were added each day.

Interval Merging Approach

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

Keep a sorted list of non-overlapping painted intervals. For each new painting task, find overlaps and merge them, calculating the new area painted.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static int intervals[1000][2];
static int result[1000];

int parseIntervals(char* line, int intervals[][2]) {
    int count = 0;
    char* ptr = line;
    
    // Find first '['
    while (*ptr && *ptr != '[') ptr++;
    if (!*ptr) return 0;
    ptr++; // skip first '['
    
    while (*ptr && count < 1000) {
        // Find next '[' for interval start
        while (*ptr && *ptr != '[') ptr++;
        if (!*ptr) break;
        ptr++; // skip '['
        
        // Parse first number
        int start = 0, sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        while (*ptr && isdigit(*ptr)) {
            start = start * 10 + (*ptr - '0');
            ptr++;
        }
        start *= sign;
        
        // Skip to next number
        while (*ptr && *ptr != '-' && !isdigit(*ptr)) ptr++;
        
        // Parse second number
        int end = 0;
        sign = 1;
        if (*ptr == '-') {
            sign = -1;
            ptr++;
        }
        while (*ptr && isdigit(*ptr)) {
            end = end * 10 + (*ptr - '0');
            ptr++;
        }
        end *= sign;
        
        intervals[count][0] = start;
        intervals[count][1] = end;
        count++;
        
        // Skip to end of this interval ']'
        while (*ptr && *ptr != ']') ptr++;
        if (*ptr == ']') ptr++;
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = parseIntervals(line, intervals);
    
    // For each day, calculate new area painted
    static int painted[200000]; // Track painted positions (offset by 100000 for negative numbers)
    int offset = 100000;
    
    for (int day = 0; day < n; day++) {
        int start = intervals[day][0];
        int end = intervals[day][1];
        int newArea = 0;
        
        // Count how many positions in [start, end) are not yet painted
        for (int pos = start; pos < end; pos++) {
            if (!painted[pos + offset]) {
                painted[pos + offset] = 1;
                newArea++;
            }
        }
        
        result[day] = newArea;
    }
    
    // Output result
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

34.5K Views

Medium Frequency

~35 min Avg. Time

892 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