Remove Interval - Practice Coding Problems

Remove Interval - Problem

Array Medium

Imagine you're managing a calendar booking system where time slots are represented as intervals. You have a collection of non-overlapping time slots that are currently booked, and you need to cancel one specific booking that might overlap with multiple existing slots.

Given a sorted list of disjoint intervals intervals where each interval [a, b) represents a half-open interval (includes a but excludes b), and another interval toBeRemoved, return the resulting intervals after removing the specified interval.

Key Points:

Intervals are half-open: [a, b) includes a but excludes b
Input intervals are already sorted and non-overlapping
The removal might split existing intervals or completely remove them
Return the final set as sorted disjoint intervals

Input & Output

example_1.py — Basic Removal

$ Input: intervals = [[0,2],[3,4],[5,7]], toBeRemoved = [1,6]

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

💡 Note: The removal interval [1,6) partially overlaps with [0,2) and [5,7). From [0,2), we keep [0,1). From [5,7), we keep [6,7). The interval [3,4) is completely contained in [1,6) so it's removed entirely.

example_2.py — Complete Removal

$ Input: intervals = [[0,5]], toBeRemoved = [2,3]

› Output: [[0,2],[3,5]]

💡 Note: The interval [0,5) is split by removing [2,3). This creates two new intervals: [0,2) and [3,5), both of which are outside the removed region.

example_3.py — No Overlap

$ Input: intervals = [[0,5]], toBeRemoved = [5,6]

› Output: [[0,5]]

💡 Note: Since intervals use half-open notation [a,b), the interval [0,5) ends at 5 (exclusive) and [5,6) starts at 5 (inclusive). There's no overlap, so the original interval is preserved.

Constraints

1 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ ai < bi ≤ 10⁹
intervals is sorted by ai in ascending order
toBeRemoved.length == 2
0 ≤ toBeRemoved[0] < toBeRemoved[1] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Identify Affected Bookings

Scan through existing reservations to find those that overlap with the cancellation

Handle Partial Overlaps

For bookings that partially overlap, split them to preserve non-cancelled portions

Remove Complete Overlaps

Entirely remove bookings that fall completely within the cancellation

Maintain Order

Ensure the final reservation list remains sorted and non-overlapping

Key Takeaway

🎯 Key Insight: Since intervals are pre-sorted and disjoint, we can process them linearly, making intelligent decisions about splits and removals in a single pass - achieving optimal O(n) performance.

Asked in

G Google 42 a Amazon 38 f Meta 24 ⊞ Microsoft 19

This interval problem is optimally solved with a single linear pass approach. Since intervals are pre-sorted and non-overlapping, we can process each interval independently, checking for three cases: no overlap (keep as-is), complete overlap (remove entirely), or partial overlap (split and keep remaining parts). The key insight is leveraging the sorted input to achieve O(n) time complexity with minimal space overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Linear Scan (Optimal)	O(n)	O(n)	Process intervals in one pass, handling overlaps efficiently
Brute Force (Check Every Interval)	O(n)	O(n)	Examine each interval individually and handle overlaps naively

Single Pass Linear Scan (Optimal) — Algorithm Steps

Iterate through intervals in order
For each interval, check its relationship with toBeRemoved
Handle three cases: no overlap (keep), complete overlap (skip), partial overlap (split)
Add resulting intervals to output maintaining sorted order
Return the final result

Visualization

Tap to expand

Step-by-Step Walkthrough

Linear Scan

Process intervals left to right in single pass

Smart Overlap Detection

Quickly identify relationship between intervals and removal target

Efficient Split Handling

Create new intervals only when necessary

Code -

solution.c — C

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

int** removeInterval(int** intervals, int intervalsSize, int* intervalsColSize, int* toBeRemoved, int* returnSize, int** returnColumnSizes) {
    // Allocate maximum possible space (each interval can split into 2)
    int** result = (int**)malloc(intervalsSize * 2 * sizeof(int*));
    *returnColumnSizes = (int*)malloc(intervalsSize * 2 * sizeof(int));
    *returnSize = 0;
    
    int removeStart = toBeRemoved[0];
    int removeEnd = toBeRemoved[1];
    
    for (int i = 0; i < intervalsSize; i++) {
        int start = intervals[i][0];
        int end = intervals[i][1];
        
        // Case 1: No overlap
        if (end <= removeStart || start >= removeEnd) {
            result[*returnSize] = (int*)malloc(2 * sizeof(int));
            result[*returnSize][0] = start;
            result[*returnSize][1] = end;
            (*returnColumnSizes)[*returnSize] = 2;
            (*returnSize)++;
        }
        // Case 2: Overlap exists
        else {
            // Left portion survives
            if (start < removeStart) {
                result[*returnSize] = (int*)malloc(2 * sizeof(int));
                result[*returnSize][0] = start;
                result[*returnSize][1] = removeStart;
                (*returnColumnSizes)[*returnSize] = 2;
                (*returnSize)++;
            }
            // Right portion survives
            if (end > removeEnd) {
                result[*returnSize] = (int*)malloc(2 * sizeof(int));
                result[*returnSize][0] = removeEnd;
                result[*returnSize][1] = end;
                (*returnColumnSizes)[*returnSize] = 2;
                (*returnSize)++;
            }
        }
    }
    
    return result;
}

int main() {
    // Parse input and execute solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all intervals with constant work per interval

✓ Linear Growth

Space Complexity

O(n)

Output space for resulting intervals, input space not counted

⚡ Linearithmic Space

28.6K Views

Medium-High Frequency

~18 min Avg. Time

845 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

Single Pass Linear Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler