Interval List Intersections - Practice Coding Problems

Interval List Intersections - Problem

Find Interval List Intersections

You're given two lists of closed intervals that are already sorted and non-overlapping within each list. Your task is to find all the intersections between intervals from the two lists.

🎯 Goal: Return a list of all intersection intervals.

What's an intersection? Two intervals [a, b] and [c, d] intersect if they share any common points. For example:
• [1, 3] and [2, 4] intersect at [2, 3]
• [1, 2] and [3, 4] don't intersect

Input: Two arrays of intervals firstList and secondList
Output: Array of intersection intervals in sorted order

Input & Output

example_1.py — Basic Intersection

$ Input: firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]

› Output: [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]

💡 Note: Each intersection is calculated as [max(start1, start2), min(end1, end2)]. For example, [0,2] and [1,5] intersect at [1,2], [5,10] and [1,5] intersect at [5,5] (a single point), and so on.

example_2.py — No Intersections

$ Input: firstList = [[1,3],[5,9]], secondList = [[4,4],[10,12]]

› Output: []

💡 Note: No intervals from the first list overlap with any intervals from the second list. [1,3] ends before [4,4] starts, [5,9] ends before [10,12] starts.

example_3.py — Empty Lists

$ Input: firstList = [], secondList = [[1,3],[5,7]]

› Output: []

💡 Note: When one list is empty, there can be no intersections, so we return an empty array.

Visualization

Tap to expand

Understanding the Visualization

Set Up Timeline

Place both schedules on the same timeline, maintaining chronological order

Compare Current Meetings

Look at the current meeting from each schedule

Find Overlap

Calculate intersection: latest start time to earliest end time

Move to Next

Advance to the next meeting for whichever executive finishes earlier

Key Takeaway

🎯 Key Insight: Two pointers work perfectly here because both lists are pre-sorted, allowing us to process intervals chronologically without backtracking.

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

We traverse each list at most once, visiting each interval exactly once

✓ Linear Growth

Space Complexity

O(k)

Only space for result array, where k is number of intersections

✓ Linear Space

Constraints

0 ≤ firstList.length, secondList.length ≤ 1000
firstList.length + secondList.length ≥ 1
0 ≤ start_i < end_i ≤ 10⁹
Both lists are sorted in non-decreasing order
Intervals within each list are disjoint (non-overlapping)

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal approach uses two pointers to traverse both sorted lists simultaneously in O(m + n) time. The key insight is that once an interval is fully processed (no longer overlaps with future intervals), we can safely advance its pointer without missing any intersections.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(m + n)	O(k)	Use two pointers to traverse both sorted lists simultaneously
Brute Force (Nested Loops)	O(m × n)	O(k)	Compare every interval from first list with every interval from second list

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers, i=0 for firstList and j=0 for secondList
While both pointers are valid, get current intervals
Calculate intersection using max(start1, start2) and min(end1, end2)
If intersection exists (start <= end), add to result
Advance the pointer of the interval that ends earlier
Continue until one list is exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Start with i=0, j=0 pointing to first intervals

Check Intersection

Calculate overlap using max(start) and min(end)

Add Valid Intersection

If overlap exists, add to result

Advance Pointer

Move pointer of interval that ends earlier

Code -

solution.c — C

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

int** intervalIntersection(int** firstList, int firstSize, int** secondList, int secondSize, int* returnSize, int** returnColumnSizes) {
    int** result = malloc(1000 * sizeof(int*));
    *returnColumnSizes = malloc(1000 * sizeof(int));
    *returnSize = 0;
    int i = 0, j = 0;
    
    // Use two pointers to traverse both lists
    while (i < firstSize && j < secondSize) {
        // Calculate intersection
        int start = firstList[i][0] > secondList[j][0] ? firstList[i][0] : secondList[j][0];
        int end = firstList[i][1] < secondList[j][1] ? firstList[i][1] : secondList[j][1];
        
        // If intersection exists, add to result
        if (start <= end) {
            result[*returnSize] = malloc(2 * sizeof(int));
            result[*returnSize][0] = start;
            result[*returnSize][1] = end;
            (*returnColumnSizes)[*returnSize] = 2;
            (*returnSize)++;
        }
        
        // Move pointer of interval that ends earlier
        if (firstList[i][1] < secondList[j][1]) {
            i++;
        } else {
            j++;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

We traverse each list at most once, visiting each interval exactly once

✓ Linear Growth

Space Complexity

O(k)

Only space for result array, where k is number of intersections

✓ Linear Space

Constraints

0 ≤ firstList.length, secondList.length ≤ 1000
firstList.length + secondList.length ≥ 1
0 ≤ start_i < end_i ≤ 10⁹
Both lists are sorted in non-decreasing order
Intervals within each list are disjoint (non-overlapping)

67.3K Views

High Frequency

~15 min Avg. Time

2.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler