Range Module - Practice Coding Problems

Range Module - Problem

Design and implement a Range Module - a data structure that efficiently tracks ranges of numbers and supports dynamic operations on them.

Your Range Module should handle half-open intervals [left, right), which include all real numbers x where left ≤ x < right.

Key Operations:

addRange(left, right) - Add all numbers in [left, right) to tracking. If some numbers are already tracked, merge the ranges intelligently.
queryRange(left, right) - Return true if every number in [left, right) is currently tracked.
removeRange(left, right) - Stop tracking all numbers in [left, right), potentially splitting existing ranges.

Example: After addRange(10, 20) and addRange(15, 25), the module tracks [10, 25). Then queryRange(12, 18) returns true, but removeRange(14, 16) would split this into [10, 14) and [16, 25).

Input & Output

example_1.py — Basic Operations

$ Input: rangeModule = RangeModule() rangeModule.addRange(10, 20) rangeModule.removeRange(14, 16) rangeModule.queryRange(10, 14) rangeModule.queryRange(13, 16) rangeModule.queryRange(16, 17)

› Output: [null, null, null, true, false, true]

💡 Note: After addRange(10,20), we track [10,20). removeRange(14,16) splits this into [10,14) and [16,20). queryRange(10,14) returns true (fully covered), queryRange(13,16) returns false (partially covered), queryRange(16,17) returns true (fully covered).

example_2.py — Merging Ranges

$ Input: rangeModule = RangeModule() rangeModule.addRange(1, 5) rangeModule.addRange(7, 10) rangeModule.addRange(4, 8) rangeModule.queryRange(1, 10)

› Output: [null, null, null, null, true]

💡 Note: First we have [1,5) and [7,10). Adding [4,8) merges all three into [1,10) since [4,8) overlaps with both existing ranges. queryRange(1,10) returns true as the entire range is covered.

example_3.py — Edge Cases

$ Input: rangeModule = RangeModule() rangeModule.queryRange(1, 5) rangeModule.addRange(1, 1) rangeModule.queryRange(1, 1)

› Output: [null, false, null, true]

💡 Note: Initially no ranges are tracked, so queryRange(1,5) returns false. addRange(1,1) adds an empty range (since [1,1) contains no numbers). queryRange(1,1) for empty range returns true.

Visualization

Tap to expand

Key Insight: Maintain sorted, non-overlapping intervals for efficient range operations

Understanding the Visualization

Book Rooms 10-20

Guest books rooms 10 through 19 (20 exclusive)

Book Rooms 15-25

Another guest books 15-24, merges with existing booking to create 10-25

Check Availability 12-18

Query if rooms 12-17 are all booked (yes, covered by 10-25)

Cancel Rooms 17-22

Cancel booking for rooms 17-21, splits 10-25 into 10-17 and 22-25

Key Takeaway

🎯 Key Insight: By maintaining sorted, non-overlapping intervals and using binary search, we can efficiently handle dynamic range operations in O(log n) to O(n) time while using minimal O(k) space.

Time & Space Complexity

Time Complexity

⏱️

O(R) per operation where R is range size

Each operation processes every number in the range individually

✓ Linear Growth

Space Complexity

O(N) where N is total numbers tracked

Stores each tracked number separately

⚡ Linearithmic Space

Constraints

1 ≤ left < right ≤ 10⁹
At most 10⁴ calls will be made to addRange, queryRange, and removeRange
Half-open intervals: [left, right) includes left but excludes right

Asked in

G Google 45 ⊞ Microsoft 32 a Amazon 28 f Meta 22

The optimal solution uses a sorted list of non-overlapping intervals with binary search for efficient operations. Key insight: maintain intervals in sorted order and merge/split them as needed. This achieves O(log n) to O(n) time complexity per operation and O(k) space where k is the number of disjoint ranges.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (List of Individual Numbers)	O(R) per operation where R is range size	O(N) where N is total numbers tracked	Store each tracked number individually in a set
Sorted Intervals with Binary Search (Optimal)	O(log n) to O(n) per operation	O(k) where k is number of disjoint intervals	Maintain sorted list of non-overlapping intervals, use binary search for efficient operations

Brute Force (List of Individual Numbers) — Algorithm Steps

Use a set to store all individual tracked numbers
addRange: Add each number from left to right-1 to the set
queryRange: Check if every number from left to right-1 exists in set
removeRange: Remove each number from left to right-1 from the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Empty set of tracked numbers

Add Range [10,15)

Add numbers 10,11,12,13,14 individually

Query Range [12,14)

Check if 12,13 exist in set

Remove Range [11,13)

Remove numbers 11,12 from set

Code -

solution.c — C

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

#define MAX_NUM 1000000

typedef struct {
    bool tracked[MAX_NUM];
} RangeModule;

RangeModule* rangeModuleCreate() {
    RangeModule* obj = (RangeModule*)calloc(1, sizeof(RangeModule));
    return obj;
}

void rangeModuleAddRange(RangeModule* obj, int left, int right) {
    for (int i = left; i < right; i++) {
        obj->tracked[i] = true;
    }
}

bool rangeModuleQueryRange(RangeModule* obj, int left, int right) {
    for (int i = left; i < right; i++) {
        if (!obj->tracked[i]) {
            return false;
        }
    }
    return true;
}

void rangeModuleRemoveRange(RangeModule* obj, int left, int right) {
    for (int i = left; i < right; i++) {
        obj->tracked[i] = false;
    }
}

void rangeModuleFree(RangeModule* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(R) per operation where R is range size

Each operation processes every number in the range individually

✓ Linear Growth

Space Complexity

O(N) where N is total numbers tracked

Stores each tracked number separately

⚡ Linearithmic Space

Constraints

1 ≤ left < right ≤ 10⁹
At most 10⁴ calls will be made to addRange, queryRange, and removeRange
Half-open intervals: [left, right) includes left but excludes right

73.4K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (List of Individual Numbers) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler