Describe the Painting - Practice Coding Problems

Describe the Painting - Problem

Imagine you're an art curator documenting a unique painting technique where artists layer colors on a canvas represented as a number line. Each artist paints a segment with their signature color, and when segments overlap, the colors mix together to create beautiful new hues!

You're given an array segments where segments[i] = [start_i, end_i, color_i] represents a half-closed interval [start_i, end_i) painted with color_i.

Color Mixing Rules:

When segments overlap, their colors mix together
Mixed colors are represented as sets: {2, 4, 6}
For simplicity, we use the sum of colors instead of the full set
Example: Colors 2, 4, and 6 mixing = sum of 12

Your Goal: Describe the final painting using the minimum number of non-overlapping segments, where each segment shows the mixed color sum for that region.

Example: If segments = [[1,4,5],[1,7,7]]:
• Region [1,4): Colors {5,7} mix → sum = 12
• Region [4,7): Only color {7} → sum = 7
• Result: [[1,4,12],[4,7,7]]

Input & Output

example_1.py — Basic Overlapping Segments

$ Input: segments = [[1,4,5],[1,7,7]]

› Output: [[1,4,12],[4,7,7]]

💡 Note: From position 1 to 4, both segments overlap so colors 5 and 7 mix giving sum 12. From position 4 to 7, only the second segment with color 7 remains.

example_2.py — Multiple Overlapping Regions

$ Input: segments = [[1,7,9],[6,8,15],[8,10,7]]

› Output: [[1,6,9],[6,7,24],[7,8,15],[8,10,7]]

💡 Note: Region [1,6): only color 9. Region [6,7): colors 9+15=24. Region [7,8): only color 15. Region [8,10): only color 7.

example_3.py — Non-overlapping Segments

$ Input: segments = [[1,4,5],[6,7,7]]

› Output: [[1,4,5],[6,7,7]]

💡 Note: No segments overlap, so each segment appears as-is in the result with its original color.

Constraints

1 ≤ segments.length ≤ 2 × 10⁴
segments[i].length == 3
1 ≤ start_i < end_i ≤ 10⁵
1 ≤ color_i ≤ 10⁹
All segments are half-closed intervals [start, end)

Visualization

Tap to expand

Understanding the Visualization

Setup Canvas

Place all paint segments on the number line canvas

Mark Events

Identify critical points where painting starts or ends

Sweep & Mix

Move sweep line left to right, tracking active colors

Output Regions

Create final segments showing mixed color sums

Key Takeaway

🎯 Key Insight: Instead of checking every coordinate, we only process the 'events' where segments start or end. The sweep line technique efficiently tracks color mixing by maintaining the active color sum as we move through these critical points.

Asked in

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

The optimal solution uses a sweep line algorithm with event processing. Create events for segment start/end points, sort them by position, then sweep through processing color changes. This achieves O(n log n) time complexity by only examining critical coordinate changes rather than every possible position.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Sweep Line (Optimal)	O(n log n)	O(n)	Process events in a single pass using coordinate compression and sweep line
Sweep Line with Event Processing	O(n log n)	O(n)	Collect all critical points, then sweep through them to build segments
Brute Force (Check Every Point)	O(n × range)	O(range)	Check each possible coordinate to see which colors are present

One-Pass Sweep Line (Optimal) — Algorithm Steps

Create events: (position, +color) for start, (position, -color) for end
Sort events by position, with end events processed before start events at same position
Sweep through events maintaining current active color sum
When color sum changes, output the previous segment (if painted)
Continue until all events processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Events

Generate start (+color) and end (-color) events from segments

Sort Events

Sort by position, end events before start at same position

Single Sweep

Process events left to right, updating active color sum

Output Segments

Create segments between events when colors are active

Code -

solution.c — C

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

typedef struct {
    int pos;
    int change;
} Event;

int compareEvents(const void* a, const void* b) {
    Event* ea = (Event*)a;
    Event* eb = (Event*)b;
    if (ea->pos != eb->pos) return ea->pos - eb->pos;
    return ea->change - eb->change;
}

int** describePainting(int** segments, int segmentsSize, int* segmentsColSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (segmentsSize == 0) return NULL;
    
    // Create events
    Event* events = (Event*)malloc(segmentsSize * 2 * sizeof(Event));
    int eventCount = 0;
    
    for (int i = 0; i < segmentsSize; i++) {
        events[eventCount++] = (Event){segments[i][0], segments[i][2]};   // paint starts
        events[eventCount++] = (Event){segments[i][1], -segments[i][2]};  // paint ends
    }
    
    // Sort events
    qsort(events, eventCount, sizeof(Event), compareEvents);
    
    // Process events
    int** result = (int**)malloc(eventCount * sizeof(int*));
    *returnColumnSizes = (int*)malloc(eventCount * sizeof(int));
    long long activeSum = 0;
    int resultIdx = 0;
    
    for (int i = 0; i < eventCount; i++) {
        int pos = events[i].pos;
        int colorChange = events[i].change;
        
        // If this is not the first event and we have active colors,
        // create segment from previous position to current position
        if (i > 0 && activeSum > 0) {
            int prevPos = events[i-1].pos;
            if (pos > prevPos) {  // avoid zero-length segments
                result[resultIdx] = (int*)malloc(3 * sizeof(int));
                result[resultIdx][0] = prevPos;
                result[resultIdx][1] = pos;
                result[resultIdx][2] = (int)activeSum;
                (*returnColumnSizes)[resultIdx] = 3;
                resultIdx++;
            }
        }
        
        // Update active colors
        activeSum += colorChange;
    }
    
    *returnSize = resultIdx;
    free(events);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting events, where n is the number of segments

⚡ Linearithmic

Space Complexity

O(n)

Store events (2n) and result segments (at most 2n)

⚡ Linearithmic Space

38.4K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

One-Pass Sweep Line (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler