Remove Covered Intervals - Practice Coding Problems

Remove Covered Intervals - Problem

Array Sorting Medium

Given an array of intervals where intervals[i] = [li, ri] represents the interval [li, ri) (left-inclusive, right-exclusive), your task is to eliminate all intervals that are completely covered by another interval in the list.

An interval [a, b) is considered covered by interval [c, d) if and only if c ≤ a and b ≤ d. In other words, one interval completely contains another.

Goal: Return the number of intervals that remain after removing all covered intervals.

Example: If we have intervals [[1,4), [3,6), [2,8)], then [1,4) is covered by [2,8) since 2 ≤ 1 is false, but [3,6) is covered by [2,8) since 2 ≤ 3 and 6 ≤ 8.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Interval [3,6] is covered by [2,8], so we remove it. Intervals [1,4] and [2,8] remain.

example_2.py — No Covered Intervals

$ Input: intervals = [[1,2],[1,4],[3,4]]

› Output: 2

💡 Note: Interval [1,2] is covered by [1,4]. The remaining intervals are [1,4] and [3,4].

example_3.py — Single Interval

$ Input: intervals = [[1,3]]

› Output: 1

💡 Note: Only one interval exists, so it cannot be covered by another interval.

Constraints

1 ≤ intervals.length ≤ 1000
intervals[i].length == 2
0 ≤ l_i ≤ r_i ≤ 10⁵
All intervals are unique (no duplicate intervals)

Visualization

Tap to expand

Understanding the Visualization

Organize Books

Sort books by their starting position on the shelf

Track Coverage

Keep track of the furthest right position covered by books we've kept

Remove Covered

Any book that ends before our furthest right position is covered by a previous book

Count Remaining

Count how many books remain after removing covered ones

Key Takeaway

🎯 Key Insight: By sorting intervals and tracking the maximum end point, we can identify covered intervals in O(n log n) time instead of O(n²).

Asked in

f Facebook 15 G Google 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses a sort + greedy scan approach. First, sort intervals by start time (ascending) and end time (descending). Then scan through sorted intervals while tracking the maximum right boundary seen so far. Any interval whose end point doesn't extend beyond this maximum is covered and can be skipped. This achieves O(n log n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	Compare every interval with every other interval to find covered ones
Sort + Greedy Scan (Optimal)	O(n log n)	O(1)	Sort intervals and greedily track the maximum right boundary

Brute Force (Nested Loops) — Algorithm Steps

Initialize a boolean array to track covered intervals
For each interval i, compare with every other interval j
If interval i is covered by interval j, mark it as covered
Count and return the number of uncovered intervals

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create array to track covered intervals

Compare All

For each interval, check against all others

Mark Covered

Mark intervals that are covered by others

Count Result

Count remaining uncovered intervals

Code -

solution.c — C

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

int removeCoveredIntervals(int** intervals, int intervalsSize) {
    bool* covered = (bool*)calloc(intervalsSize, sizeof(bool));
    
    for (int i = 0; i < intervalsSize; i++) {
        for (int j = 0; j < intervalsSize; j++) {
            if (i != j) {
                // Check if interval i is covered by interval j
                if (intervals[j][0] <= intervals[i][0] && intervals[i][1] <= intervals[j][1]) {
                    covered[i] = true;
                    break;
                }
            }
        }
    }
    
    // Count uncovered intervals
    int count = 0;
    for (int i = 0; i < intervalsSize; i++) {
        if (!covered[i]) count++;
    }
    
    free(covered);
    return count;
}

int main() {
    // Example usage
    int arr[][2] = {{1,4},{3,6},{2,8}};
    int* intervals[3];
    for (int i = 0; i < 3; i++) {
        intervals[i] = arr[i];
    }
    printf("%d\n", removeCoveredIntervals(intervals, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We compare each interval with every other interval, resulting in n×n comparisons

⚠ Quadratic Growth

Space Complexity

O(n)

We need additional space to track which intervals are covered

⚡ Linearithmic Space

24.7K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler