Check if All the Integers in a Range Are Covered - Problem

You are given a 2D integer array ranges and two integers left and right. Each ranges[i] = [start_i, end_i] represents an inclusive interval between start_i and end_i.

Return true if each integer in the inclusive range [left, right] is covered by at least one interval in ranges. Return false otherwise.

An integer x is covered by an interval ranges[i] = [start_i, end_i] if start_i <= x <= end_i.

Input & Output

Example 1 — Basic Coverage

$ Input: ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5

› Output: true

💡 Note: Every integer 2,3,4,5 is covered: 2 is in [1,2], 3 is in [3,4], 4 is in [3,4], 5 is in [5,6]

Example 2 — Gap in Coverage

$ Input: ranges = [[1,10],[10,20]], left = 1, right = 21

› Output: false

💡 Note: Numbers 1-20 are covered by the ranges, but 21 is not covered by any range

Example 3 — Single Number Range

$ Input: ranges = [[1,1],[2,2],[3,3]], left = 1, right = 3

› Output: true

💡 Note: Each number 1,2,3 is exactly covered by its corresponding single-number range

Constraints

1 ≤ ranges.length ≤ 50
1 ≤ start_i ≤ end_i ≤ 50
1 ≤ left ≤ right ≤ 50

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is to check if every number in the target range [left, right] is covered by at least one interval. The brute force approach checks each number against all ranges. The hash set approach pre-marks all covered numbers for O(1) lookup. Best approach depends on range sizes: brute force for small ranges, hash set for large coverage areas. Time: O(n×m), Space: O(1) for brute force.

Common Approaches

✓ Brute Force - Check Each Number

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

For each number in the target range [left, right], iterate through all ranges to see if at least one range covers it. If any number is not covered, return false.

Hash Set - Mark Covered Numbers

⏱️ Time: O(S + (right - left)) Space: O(S)

First pass: iterate through all ranges and mark every number they cover in a hash set. Second pass: check if every number from left to right exists in the hash set.

Optimized - Smart Coverage Check

⏱️ Time: O((right - left) × n) Space: O(1)

For each number in the target range, check if it falls within any of the given ranges. Stop early if any number is not covered. This avoids creating large hash sets.

Brute Force - Check Each Number — Algorithm Steps

Iterate through each number from left to right
For each number, check if any range covers it
Return false if any number is uncovered, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Check 1

Is 1 covered by any range?

Check 2

Is 2 covered by any range?

Continue

Check each number until 50

Code -

solution.c — C

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

bool solution(int ranges[][2], int rangesSize, int left, int right) {
    for (int num = left; num <= right; num++) {
        bool covered = false;
        for (int i = 0; i < rangesSize; i++) {
            if (ranges[i][0] <= num && num <= ranges[i][1]) {
                covered = true;
                break;
            }
        }
        if (!covered) {
            return false;
        }
    }
    return true;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for ranges
    int ranges[50][2];
    int rangesSize = 0;
    char* ptr = line + 1; // Skip first '['
    while (*ptr && rangesSize < 50) {
        if (*ptr == '[') {
            ptr++;
            ranges[rangesSize][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            if (*ptr == ',') ptr++;
            ranges[rangesSize][1] = atoi(ptr);
            rangesSize++;
            while (*ptr && *ptr != ']') ptr++;
            if (*ptr == ']') ptr++;
        } else {
            ptr++;
        }
    }
    
    int left, right;
    scanf("%d", &left);
    scanf("%d", &right);
    
    bool result = solution(ranges, rangesSize, left, right);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of the (right-left+1) numbers, we check all n ranges

✓ Linear Growth

Space Complexity

O(1)

Only using variables, no extra data structures

✓ Linear Space

35.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Check if All the Integers in a Range Are Covered - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Each Number — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler