Missing Ranges - Practice Coding Problems

Missing Ranges - Problem

Array Easy

Missing Ranges is a classic interval problem that tests your ability to identify gaps in data.

You're given a sorted unique integer array nums and an inclusive range [lower, upper]. All elements in nums are guaranteed to be within this range. Your task is to find all the missing numbers and return them as the shortest possible list of ranges.

For example, if you have nums = [0, 1, 3, 50, 75] and range [0, 99], the missing numbers are 2, 4-49, 51-74, and 76-99. You need to represent single missing numbers as strings like "2" and ranges as "4->49".

Goal: Return a list of range strings that cover all missing numbers with no overlaps or redundancy.

Input & Output

example_1.py — Basic Case

$ Input: nums = [0, 1, 3, 50, 75], lower = 0, upper = 99

› Output: ["2", "4->49", "51->74", "76->99"]

💡 Note: Missing numbers: 2 (single), 4-49 (range), 51-74 (range), 76-99 (range). Each missing number or consecutive group is represented as a range string.

example_2.py — Empty Array

$ Input: nums = [], lower = 1, upper = 1

› Output: ["1"]

💡 Note: When nums is empty, the entire range [lower, upper] is missing. Since lower equals upper, we have a single missing number.

example_3.py — No Missing Numbers

$ Input: nums = [-1], lower = -1, upper = -1

› Output: []

💡 Note: The array contains the only number in the range [-1, -1], so there are no missing numbers to report.

Constraints

-10⁹ ≤ lower ≤ upper ≤ 10⁹
0 ≤ nums.length ≤ 100
lower ≤ nums[i] ≤ upper
All values of nums are unique and sorted in ascending order

Visualization

Tap to expand

Understanding the Visualization

Check Lobby Area

Are there available rooms before the first booked room?

Walk Through Floors

Walk past each booked room and check for gaps to the next booking

Check Top Floors

Are there available rooms after the last booked room?

Generate Report

Format available rooms as ranges for the guest services team

Key Takeaway

🎯 Key Insight: By walking through the sorted bookings once and checking gaps, we efficiently find all available ranges without examining every room number.

Asked in

G Google 42 f Meta 38 a Amazon 29 ⊞ Microsoft 25

The optimal solution uses a single pass through the sorted array to identify gaps. By checking boundaries and consecutive elements, we can find all missing ranges in O(n) time with O(1) space. The key insight is leveraging the sorted property rather than checking every number individually.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Linear Scan (Optimal)	O(n)	O(1)	Single pass through sorted array to find gaps between consecutive elements
Brute Force (Check Every Number)	O(n + (upper-lower))	O(n)	Check each number in [lower, upper] to see if it exists in nums

One-Pass Linear Scan (Optimal) — Algorithm Steps

Handle gap before the first element [lower, nums[0]-1]
Iterate through consecutive pairs in nums array
For each pair, check if there's a gap and add missing range
Handle gap after the last element [nums[-1]+1, upper]
Format ranges appropriately (single numbers vs ranges)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Before First

Check gap between lower and nums[0]

Check Between Elements

Find gaps between consecutive elements in nums

Check After Last

Check gap between nums[-1] and upper

Code -

solution.c — C

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

#define MAX_RANGES 1000
#define MAX_STR_LEN 50

void formatRange(char* buffer, int start, int end) {
    if (start == end) {
        sprintf(buffer, "%d", start);
    } else {
        sprintf(buffer, "%d->%d", start, end);
    }
}

char** findMissingRanges(int* nums, int numsSize, int lower, int upper, int* returnSize) {
    char** result = (char**)malloc(MAX_RANGES * sizeof(char*));
    *returnSize = 0;
    
    if (numsSize == 0) {
        result[0] = (char*)malloc(MAX_STR_LEN * sizeof(char));
        formatRange(result[0], lower, upper);
        *returnSize = 1;
        return result;
    }
    
    // Check for gap before first element
    if (nums[0] > lower) {
        result[*returnSize] = (char*)malloc(MAX_STR_LEN * sizeof(char));
        formatRange(result[*returnSize], lower, nums[0] - 1);
        (*returnSize)++;
    }
    
    // Check for gaps between consecutive elements
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i + 1] - nums[i] > 1) {
            result[*returnSize] = (char*)malloc(MAX_STR_LEN * sizeof(char));
            formatRange(result[*returnSize], nums[i] + 1, nums[i + 1] - 1);
            (*returnSize)++;
        }
    }
    
    // Check for gap after last element
    if (nums[numsSize - 1] < upper) {
        result[*returnSize] = (char*)malloc(MAX_STR_LEN * sizeof(char));
        formatRange(result[*returnSize], nums[numsSize - 1] + 1, upper);
        (*returnSize)++;
    }
    
    return result;
}

int main() {
    int nums[] = {0, 1, 3, 50, 75};
    int numsSize = 5;
    int lower = 0, upper = 99;
    int returnSize;
    
    char** result = findMissingRanges(nums, numsSize, lower, upper, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the nums array of length n

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables (excluding output array)

✓ Linear Space

78.2K Views

Medium-High Frequency

~18 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Linear Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler