Find Maximal Uncovered Ranges

Find Maximal Uncovered Ranges - Problem

Array Sorting Medium

You are given an integer n which is the length of a 0-indexed array nums, and a 0-indexed 2D-array ranges, which is a list of sub-ranges of nums (sub-ranges may overlap).

Each row ranges[i] has exactly 2 cells:

ranges[i][0], which shows the start of the ith range (inclusive)
ranges[i][1], which shows the end of the ith range (inclusive)

These ranges cover some cells of nums and leave some cells uncovered. Your task is to find all of the uncovered ranges with maximal length.

Return a 2D-array answer of the uncovered ranges, sorted by the starting point in ascending order.

By all of the uncovered ranges with maximal length, we mean satisfying two conditions:

Each uncovered cell should belong to exactly one sub-range
There should not exist two ranges (l1, r1) and (l2, r2) such that r1 + 1 = l2

Input & Output

Example 1 — Basic Case

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

› Output: [[3,4]]

💡 Note: Positions 0-2 are covered by [0,2], positions 5-7 are covered by [5,7]. Positions 3-4 are uncovered, forming one maximal range [3,4].

Example 2 — Multiple Gaps

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

› Output: [[0,1],[4,6],[9,9]]

💡 Note: Three uncovered ranges: [0,1] before first range, [4,6] between ranges, and [9,9] after last range.

Example 3 — Overlapping Ranges

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

› Output: [[0,0]]

💡 Note: Ranges [1,3] and [2,5] overlap and merge to [1,5]. Only position 0 is uncovered.

Constraints

1 ≤ n ≤ 50
0 ≤ ranges.length ≤ 50
ranges[i].length == 2
0 ≤ ranges[i][0] ≤ ranges[i][1] < n

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to merge overlapping ranges first, then find gaps between merged ranges. The optimal approach sorts ranges by start position O(m log m), merges overlapping ones, then scans for gaps. Time: O(m log m), Space: O(m)

Common Approaches

✓ Brute Force Check Each Position

⏱️ Time: O(n × m) Space: O(1)

For each position from 0 to n-1, check if it's covered by any range. Group consecutive uncovered positions into ranges.

Sort and Merge Ranges

⏱️ Time: O(m log m) Space: O(m)

Sort ranges by start position, merge overlapping ranges into non-overlapping intervals, then scan for gaps between merged ranges.

Brute Force Check Each Position — Algorithm Steps

Step 1: For each position 0 to n-1, check all ranges to see if position is covered
Step 2: Group consecutive uncovered positions into maximal ranges

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position

For each position, scan all ranges

Mark Coverage

Determine if position is covered

Group Gaps

Collect consecutive uncovered positions

Code -

solution.c — C

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

int** solution(int n, int** ranges, int rangesSize, int* returnSize, int** returnColumnSizes) {
    int** result = malloc(n * sizeof(int*));
    *returnColumnSizes = malloc(n * sizeof(int));
    *returnSize = 0;
    int start = -1;
    
    for (int i = 0; i < n; i++) {
        int covered = 0;
        for (int j = 0; j < rangesSize; j++) {
            if (ranges[j][0] <= i && i <= ranges[j][1]) {
                covered = 1;
                break;
            }
        }
        
        if (!covered) {
            if (start == -1) {
                start = i;
            }
        } else {
            if (start != -1) {
                result[*returnSize] = malloc(2 * sizeof(int));
                result[*returnSize][0] = start;
                result[*returnSize][1] = i - 1;
                (*returnColumnSizes)[*returnSize] = 2;
                (*returnSize)++;
                start = -1;
            }
        }
    }
    
    if (start != -1) {
        result[*returnSize] = malloc(2 * sizeof(int));
        result[*returnSize][0] = start;
        result[*returnSize][1] = n - 1;
        (*returnColumnSizes)[*returnSize] = 2;
        (*returnSize)++;
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    getchar();
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int rangesSize = 0;
    int** ranges = malloc(50 * sizeof(int*));
    
    // Parse JSON array
    char* ptr = line;
    
    // Skip whitespace and find opening bracket
    while (*ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')) ptr++;
    
    if (*ptr == '[') {
        ptr++;
        // Skip whitespace after opening bracket
        while (*ptr && (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')) ptr++;
        
        // Check if empty array
        if (*ptr != ']') {
            // Parse ranges
            while (*ptr && *ptr != ']') {
                // Skip whitespace and find opening bracket of range
                while (*ptr && *ptr != '[') ptr++;
                if (*ptr != '[') break;
                ptr++;
                
                ranges[rangesSize] = malloc(2 * sizeof(int));
                
                // Parse first number
                while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++;
                ranges[rangesSize][0] = atoi(ptr);
                
                // Skip digits and find comma
                while (*ptr && (*ptr != ',')) ptr++;
                if (*ptr == ',') ptr++;
                
                // Parse second number
                while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++;
                ranges[rangesSize][1] = atoi(ptr);
                
                // Find closing bracket
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
                
                rangesSize++;
                
                // Check for comma (next range)
                while (*ptr && (*ptr == ' ' || *ptr == '\t')) ptr++;
                if (*ptr == ',') {
                    ptr++;
                    continue;
                }
                break;
            }
        }
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(n, ranges, rangesSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < rangesSize; i++) {
        free(ranges[i]);
    }
    free(ranges);
    
    for (int i = 0; i < returnSize; i++) {
        free(result[i]);
    }
    free(result);
    free(returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of n positions, we check m ranges

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking, excluding output space

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 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 Check Each Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler