Range Module

Range Module - Problem

A Range Module is a module that tracks ranges of numbers. Design a data structure to track the ranges represented as half-open intervals and query about them.

A half-open interval [left, right) denotes all the real numbers x where left <= x < right.

Implement the RangeModule class:

RangeModule() Initializes the object of the data structure.
void addRange(int left, int right) Adds the half-open interval [left, right), tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval [left, right) that are not already tracked.
boolean queryRange(int left, int right) Returns true if every real number in the interval [left, right) is currently being tracked, and false otherwise.
void removeRange(int left, int right) Stops tracking every real number currently being tracked in the half-open interval [left, right).

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["RangeModule", "addRange", "removeRange", "queryRange", "queryRange"], params = [[], [10, 20], [14, 16], [10, 14], [13, 15]]

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

💡 Note: RangeModule initializes empty. addRange(10, 20) tracks [10, 20). removeRange(14, 16) removes [14, 16), leaving [10, 14) and [16, 20). queryRange(10, 14) returns true (fully covered). queryRange(13, 15) returns false (15 not tracked).

Example 2 — Overlapping Ranges

$ Input: operations = ["RangeModule", "addRange", "addRange", "queryRange"], params = [[], [10, 15], [12, 18], [10, 18]]

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

💡 Note: addRange(10, 15) tracks [10, 15). addRange(12, 18) merges with existing to track [10, 18). queryRange(10, 18) returns true (fully covered).

Example 3 — Edge Case Empty Query

$ Input: operations = ["RangeModule", "queryRange"], params = [[], [1, 5]]

› Output: [null, false]

💡 Note: Empty RangeModule has no tracked ranges, so queryRange(1, 5) returns false.

Constraints

1 ≤ left < right ≤ 10⁹
At most 10⁴ calls will be made to addRange, queryRange, and removeRange.

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to maintain non-overlapping intervals and merge them efficiently. Best approach uses interval merging with O(n) time for operations and O(n) space for storing intervals.

Common Approaches

✓ Brute Force with Set

⏱️ Time: O(n) Space: O(n)

Maintain a set of all tracked numbers. For addRange, add each number individually. For queryRange, check if all numbers exist. For removeRange, remove each number individually.

Interval Merging

⏱️ Time: O(n) Space: O(n)

Maintain a list of non-overlapping intervals sorted by start time. When adding ranges, merge with existing intervals. When querying, check if the range is fully covered by existing intervals.

Brute Force with Set — Algorithm Steps

Store individual numbers in a set
Add/remove numbers one by one
Query by checking each number exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty set

Add Range

Add each number individually

Query/Remove

Check/remove each number individually

Code -

solution.c — C

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

typedef struct {
    int left;
    int right;
} Interval;

typedef struct {
    Interval* intervals;
    int capacity;
    int size;
} RangeModule;

RangeModule* rangeModuleCreate() {
    RangeModule* rm = (RangeModule*)malloc(sizeof(RangeModule));
    rm->intervals = (Interval*)malloc(1000 * sizeof(Interval));
    rm->capacity = 1000;
    rm->size = 0;
    return rm;
}

void rangeModuleAddRange(RangeModule* rm, int left, int right) {
    Interval* newIntervals = (Interval*)malloc(1000 * sizeof(Interval));
    int newSize = 0;
    int i = 0;
    
    // Add non-overlapping intervals before the new range
    while (i < rm->size && rm->intervals[i].right < left) {
        newIntervals[newSize++] = rm->intervals[i];
        i++;
    }
    
    // Merge overlapping intervals
    int mergedLeft = left, mergedRight = right;
    while (i < rm->size && rm->intervals[i].left <= right) {
        if (rm->intervals[i].left < mergedLeft) mergedLeft = rm->intervals[i].left;
        if (rm->intervals[i].right > mergedRight) mergedRight = rm->intervals[i].right;
        i++;
    }
    
    newIntervals[newSize].left = mergedLeft;
    newIntervals[newSize].right = mergedRight;
    newSize++;
    
    // Add remaining intervals
    while (i < rm->size) {
        newIntervals[newSize++] = rm->intervals[i];
        i++;
    }
    
    free(rm->intervals);
    rm->intervals = newIntervals;
    rm->size = newSize;
}

bool rangeModuleQueryRange(RangeModule* rm, int left, int right) {
    for (int i = 0; i < rm->size; i++) {
        if (rm->intervals[i].left <= left && rm->intervals[i].right >= right) {
            return true;
        }
    }
    return false;
}

void rangeModuleRemoveRange(RangeModule* rm, int left, int right) {
    Interval* newIntervals = (Interval*)malloc(1000 * sizeof(Interval));
    int newSize = 0;
    
    for (int i = 0; i < rm->size; i++) {
        if (rm->intervals[i].right <= left || rm->intervals[i].left >= right) {
            newIntervals[newSize++] = rm->intervals[i];
        } else {
            if (rm->intervals[i].left < left) {
                newIntervals[newSize].left = rm->intervals[i].left;
                newIntervals[newSize].right = left;
                newSize++;
            }
            if (rm->intervals[i].right > right) {
                newIntervals[newSize].left = right;
                newIntervals[newSize].right = rm->intervals[i].right;
                newSize++;
            }
        }
    }
    
    free(rm->intervals);
    rm->intervals = newIntervals;
    rm->size = newSize;
}

static char operations[1000][20];
static int params[1000][2];
static int operationCount = 0;
static char* results[1000];
static bool hasParams[1000];

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Parse operations
    operationCount = 0;
    char* ptr = line1;
    while (*ptr) {
        if (*ptr == '"') {
            ptr++;
            int i = 0;
            while (*ptr && *ptr != '"') {
                operations[operationCount][i++] = *ptr++;
            }
            operations[operationCount][i] = '\0';
            operationCount++;
            if (*ptr == '"') ptr++;
        } else {
            ptr++;
        }
    }
    
    // Parse params
    ptr = line2;
    int paramIndex = 0;
    while (*ptr && paramIndex < operationCount) {
        if (*ptr == '[') {
            ptr++;
            if (*ptr == ']') {
                // Empty array
                hasParams[paramIndex] = false;
                ptr++;
            } else {
                // Parse two numbers
                hasParams[paramIndex] = true;
                char* endptr;
                params[paramIndex][0] = (int)strtol(ptr, &endptr, 10);
                ptr = endptr;
                while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                params[paramIndex][1] = (int)strtol(ptr, &endptr, 10);
                ptr = endptr;
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            }
            paramIndex++;
        } else {
            ptr++;
        }
    }
    
    // Execute solution
    RangeModule* rm = NULL;
    
    for (int i = 0; i < operationCount; i++) {
        if (strcmp(operations[i], "RangeModule") == 0) {
            rm = rangeModuleCreate();
            results[i] = "null";
        } else if (strcmp(operations[i], "addRange") == 0) {
            rangeModuleAddRange(rm, params[i][0], params[i][1]);
            results[i] = "null";
        } else if (strcmp(operations[i], "queryRange") == 0) {
            results[i] = rangeModuleQueryRange(rm, params[i][0], params[i][1]) ? "true" : "false";
        } else if (strcmp(operations[i], "removeRange") == 0) {
            rangeModuleRemoveRange(rm, params[i][0], params[i][1]);
            results[i] = "null";
        }
    }
    
    printf("[");
    for (int i = 0; i < operationCount; i++) {
        printf("%s", results[i]);
        if (i < operationCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation may process up to n individual numbers

✓ Linear Growth

Space Complexity

O(n)

Set stores up to n individual numbers

⚡ Linearithmic Space

32.1K Views

Medium Frequency

~35 min Avg. Time

856 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 with Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler