Find Right Interval - Practice Coding Problems

Find Right Interval - Problem

Find Right Interval is a classic interval processing problem that tests your understanding of sorting and binary search techniques.

You are given an array of intervals where intervals[i] = [start_i, end_i] and each start_i is unique. For each interval, you need to find its "right interval" - which is another interval whose start point is greater than or equal to the current interval's end point, and among all such valid intervals, you want the one with the smallest start point.

Goal: Return an array where each index contains the index of the right interval for the corresponding input interval, or -1 if no such interval exists.

Key Points:
• An interval can be its own right interval if its start ≥ its end
• We want the minimized start point among all valid right intervals
• Each start point is guaranteed to be unique

Input & Output

example_1.py — Basic intervals

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

› Output: [-1]

💡 Note: There is only one interval, and its end (2) is greater than its start (1), so there's no right interval.

example_2.py — Multiple intervals

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

› Output: [2, 1, 0]

💡 Note: For [3,4]: need start >= 4, no such interval exists → -1. Wait, that's wrong. Let me recalculate: For [3,4]: need start >= 4, none exist → -1. For [2,3]: need start >= 3, found [3,4] at index 0. For [1,2]: need start >= 2, found [2,3] at index 1. So result should be [-1, 0, 1].

example_3.py — Self-reference case

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

› Output: [-1, 2, -1]

💡 Note: For [1,4]: need start >= 4, no interval starts at or after 4. For [2,3]: need start >= 3, found [3,4] at index 2. For [3,4]: need start >= 4, no such interval exists.

Visualization

Tap to expand

Understanding the Visualization

Organize Schedule

Sort all bus departure times in chronological order

Quick Lookup

For each arrival time, use binary search to quickly find the next departure

Get Connection

Return the bus route index for the connecting bus

Key Takeaway

🎯 Key Insight: By sorting departure times once, we can use binary search to quickly find the next available connection for each arrival, reducing time complexity from O(n²) to O(n log n).

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for n binary searches

⚡ Linearithmic

Space Complexity

O(n)

Extra space for sorted array and index mappings

⚡ Linearithmic Space

Constraints

1 ≤ intervals.length ≤ 2 × 10⁴
intervals[i].length == 2
-10⁶ ≤ start_i ≤ end_i ≤ 10⁶
The start point of each interval is unique

Asked in

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

The optimal approach uses sorting + binary search to achieve O(n log n) time complexity. First, create a sorted array of start times with their original indices. Then, for each interval's end time, use binary search to find the leftmost start time that is greater than or equal to it.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n)	O(n)	Sort intervals by start time, then binary search for right interval
Brute Force (Nested Loops)	O(n²)	O(1)	For each interval, check all other intervals to find the right interval

Sorting + Binary Search — Algorithm Steps

Create array of (start, originalIndex) pairs
Sort this array by start values
For each original interval, binary search for smallest start >= end
Map back to original indices using the stored mapping

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Start

Sort all intervals by their start times

Binary Search

For each interval's end, binary search for the leftmost start >= end

Map Back

Return the original index of the found interval

Code -

solution.c — C

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

typedef struct {
    int start;
    int index;
} Interval;

int compare(const void* a, const void* b) {
    return ((Interval*)a)->start - ((Interval*)b)->start;
}

int* findRightInterval(int** intervals, int intervalsSize, int* intervalsColSize, int* returnSize) {
    *returnSize = intervalsSize;
    int* result = (int*)malloc(intervalsSize * sizeof(int));
    
    // Create array of start times with indices
    Interval* starts = (Interval*)malloc(intervalsSize * sizeof(Interval));
    for (int i = 0; i < intervalsSize; i++) {
        starts[i].start = intervals[i][0];
        starts[i].index = i;
    }
    // Sort by start time
    qsort(starts, intervalsSize, sizeof(Interval), compare);
    
    for (int i = 0; i < intervalsSize; i++) {
        int end = intervals[i][1];
        // Binary search for leftmost start >= end
        int left = 0, right = intervalsSize;
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (starts[mid].start >= end) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        
        result[i] = (left < intervalsSize) ? starts[left].index : -1;
    }
    
    free(starts);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n log n) for n binary searches

⚡ Linearithmic

Space Complexity

O(n)

Extra space for sorted array and index mappings

⚡ Linearithmic Space

Constraints

1 ≤ intervals.length ≤ 2 × 10⁴
intervals[i].length == 2
-10⁶ ≤ start_i ≤ end_i ≤ 10⁶
The start point of each interval is unique

23.4K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler