Find Maximal Uncovered Ranges - Practice Coding Problems

Find Maximal Uncovered Ranges - Problem

Array Sorting Medium

🎯 Find Maximal Uncovered Ranges

Imagine you have a bookshelf with n positions (indexed 0 to n-1), and you're given a list of ranges that represent which sections are already occupied by books. Your task is to find all the empty sections on the shelf, but with a twist - you want to group adjacent empty positions into the largest possible continuous ranges.

Given:

n - the total length of the array (bookshelf)
ranges - a 2D array where each ranges[i] = [start, end] represents a covered section (inclusive)

Goal: Return all uncovered ranges in their maximal form, sorted by starting position.

Key Rules:

Each uncovered position should belong to exactly one range
Adjacent ranges should be merged (e.g., [1,2] and [3,4] become [1,4])
Ranges may overlap in the input - handle this correctly!

Example: If n=5 and ranges=[[0,1], [3,3]], then positions 0,1,3 are covered, leaving positions 2 and 4 uncovered. The result is [[2,2], [4,4]].

Input & Output

example_1.py — Basic Case

$ Input: n = 5, ranges = [[0, 1], [3, 3]]

› Output: [[2, 2], [4, 4]]

💡 Note: Positions 0, 1, and 3 are covered. Positions 2 and 4 are uncovered, each forming their own maximal range.

example_2.py — Overlapping Ranges

$ Input: n = 8, ranges = [[1, 3], [2, 5], [7, 7]]

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

💡 Note: Ranges [1,3] and [2,5] overlap and merge to cover [1,5]. Position 7 is also covered. Uncovered positions are 0 and 6.

example_3.py — Edge Case - No Ranges

$ Input: n = 3, ranges = []

› Output: [[0, 2]]

💡 Note: No positions are covered, so the entire array [0, 2] is one maximal uncovered range.

Constraints

1 ≤ n ≤ 10⁴
0 ≤ ranges.length ≤ 100
ranges[i].length == 2
0 ≤ ranges[i][0] ≤ ranges[i][1] < n
Ranges may overlap or be adjacent

Visualization

Tap to expand

Understanding the Visualization

Initial State

The shelf has scattered book sections covering various ranges

Sort Sections

Arrange book sections in order from left to right

Merge Adjacent

Combine overlapping or touching book sections

Find Gaps

Identify all empty spaces between organized book sections

Key Takeaway

🎯 Key Insight: By first merging overlapping ranges, we transform a complex coverage problem into a simple gap-finding problem between sorted intervals.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach is to sort and merge the overlapping ranges first, then find gaps between the merged ranges. This transforms the complex problem of avoiding multiple overlapping ranges into the simpler problem of finding gaps between non-overlapping sorted intervals. Time complexity: O(m log m) where m is the number of ranges.

Common Approaches

Approach	Time	Space	Notes
✓ Sort Ranges + Merge Intervals	O(m log m + m)	O(m)	Sort ranges, merge overlapping ones, then find gaps between merged ranges
Brute Force (Check Every Position)	O(n × m)	O(n)	Check each position individually to see if it's covered, then group adjacent uncovered positions

Sort Ranges + Merge Intervals — Algorithm Steps

Sort all ranges by their start position
Merge overlapping or adjacent ranges using two pointers
Scan through merged ranges to find gaps
Convert gaps to uncovered ranges within bounds [0, n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Ranges

Sort all input ranges by their start position

Merge Overlapping

Combine overlapping or adjacent ranges into larger ones

Find Gaps

Identify gaps between merged ranges

Return Result

Convert gaps to uncovered ranges within [0, n-1]

Code -

solution.c — C

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

int compareRanges(const void* a, const void* b) {
    int* rangeA = (int*)a;
    int* rangeB = (int*)b;
    return rangeA[0] - rangeB[0];
}

int** findMaximalUncoveredRanges(int n, int** ranges, int rangesSize, int* returnSize) {
    *returnSize = 0;
    int** result = (int**)malloc(n * sizeof(int*));
    
    if (rangesSize == 0) {
        if (n > 0) {
            result[0] = (int*)malloc(2 * sizeof(int));
            result[0][0] = 0;
            result[0][1] = n - 1;
            *returnSize = 1;
        }
        return result;
    }
    
    // Sort ranges by start position
    qsort(ranges, rangesSize, 2 * sizeof(int), compareRanges);
    
    // Merge overlapping ranges
    int** merged = (int**)malloc(rangesSize * sizeof(int*));
    int mergedSize = 0;
    
    for (int i = 0; i < rangesSize; i++) {
        if (mergedSize > 0 && ranges[i][0] <= merged[mergedSize-1][1] + 1) {
            // Overlapping or adjacent - merge
            if (ranges[i][1] > merged[mergedSize-1][1]) {
                merged[mergedSize-1][1] = ranges[i][1];
            }
        } else {
            // Non-overlapping - add new range
            merged[mergedSize] = (int*)malloc(2 * sizeof(int));
            merged[mergedSize][0] = ranges[i][0];
            merged[mergedSize][1] = ranges[i][1];
            mergedSize++;
        }
    }
    
    // Find gaps between merged ranges
    // Check gap before first range
    if (merged[0][0] > 0) {
        result[*returnSize] = (int*)malloc(2 * sizeof(int));
        result[*returnSize][0] = 0;
        result[*returnSize][1] = merged[0][0] - 1;
        (*returnSize)++;
    }
    
    // Check gaps between consecutive ranges
    for (int i = 0; i < mergedSize - 1; i++) {
        int gapStart = merged[i][1] + 1;
        int gapEnd = merged[i + 1][0] - 1;
        if (gapStart <= gapEnd) {
            result[*returnSize] = (int*)malloc(2 * sizeof(int));
            result[*returnSize][0] = gapStart;
            result[*returnSize][1] = gapEnd;
            (*returnSize)++;
        }
    }
    
    // Check gap after last range
    if (merged[mergedSize-1][1] < n - 1) {
        result[*returnSize] = (int*)malloc(2 * sizeof(int));
        result[*returnSize][0] = merged[mergedSize-1][1] + 1;
        result[*returnSize][1] = n - 1;
        (*returnSize)++;
    }
    
    // Free merged array
    for (int i = 0; i < mergedSize; i++) {
        free(merged[i]);
    }
    free(merged);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m log m + m)

Sorting m ranges takes O(m log m), merging and finding gaps takes O(m)

⚡ Linearithmic

Space Complexity

O(m)

Space for merged ranges, at most m ranges

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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

🎯 Find Maximal Uncovered Ranges

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Sort Ranges + Merge Intervals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler