Data Stream as Disjoint Intervals

Data Stream as Disjoint Intervals - Problem

Hash Table Binary Search Union Find Design Data Stream Ordered Set Hard

Given a data stream input of non-negative integers a₁, a₂, ..., aₙ, summarize the numbers seen so far as a list of disjoint intervals.

Implement the SummaryRanges class:

SummaryRanges() Initializes the object with an empty stream.
void addNum(int value) Adds the integer value to the stream.
int[][] getIntervals() Returns a summary of the integers in the stream currently as a list of disjoint intervals [startᵢ, endᵢ].

The answer should be sorted by startᵢ.

Input & Output

Example 1 — Basic Stream Operations

$ Input: operations = ["SummaryRanges", "addNum", "getIntervals", "addNum", "getIntervals", "addNum", "getIntervals", "getIntervals"], values = [null, 1, null, 3, null, 2, null, null]

› Output: [null, null, [[1,1]], null, [[1,1],[3,3]], null, [[1,3]], [[1,3]]]

💡 Note: Initialize empty stream, add 1 → [[1,1]], add 3 → [[1,1],[3,3]], add 2 → merges to [[1,3]]

Example 2 — Single Interval Growth

$ Input: operations = ["SummaryRanges", "addNum", "addNum", "getIntervals"], values = [null, 1, 2, null]

› Output: [null, null, null, [[1,2]]]

💡 Note: Add consecutive numbers 1 and 2, they merge into single interval [1,2]

Example 3 — No Merging Needed

$ Input: operations = ["SummaryRanges", "addNum", "addNum", "getIntervals"], values = [null, 1, 5, null]

› Output: [null, null, null, [[1,1],[5,5]]]

💡 Note: Numbers 1 and 5 are not adjacent, so they remain as separate intervals

Constraints

0 ≤ value ≤ 10⁴
At most 3 × 10⁴ calls to addNum and getIntervals

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 🍎 Apple 28

The key insight is maintaining sorted disjoint intervals and efficiently merging adjacent/overlapping ones when adding new numbers. Best approach uses binary search for O(log n) insertion position finding with smart interval merging. Time: O(n) worst case per operation, Space: O(n)

Common Approaches

✓ Brute Force - Rebuild Intervals

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

Keep a set of all numbers seen so far. When getIntervals is called, sort all numbers and build intervals by iterating through consecutive numbers.

Sorted List with Binary Search

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

Keep intervals sorted by start position. When adding a number, use binary search to find insertion point and merge overlapping or adjacent intervals.

Brute Force - Rebuild Intervals — Algorithm Steps

Store each new number in a set
On getIntervals: sort all numbers
Iterate through sorted numbers to form consecutive intervals

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Numbers

Add each number to a set

Sort & Rebuild

Sort all numbers and form intervals

Return Intervals

Output the disjoint intervals

Code -

solution.c — C

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

#define MAX_NUMS 10000

typedef struct {
    int nums[MAX_NUMS];
    bool exists[MAX_NUMS];
    int maxVal;
} SummaryRanges;

SummaryRanges* summaryRangesCreate() {
    SummaryRanges* obj = (SummaryRanges*)malloc(sizeof(SummaryRanges));
    memset(obj->exists, false, sizeof(obj->exists));
    obj->maxVal = -1;
    return obj;
}

void summaryRangesAddNum(SummaryRanges* obj, int value) {
    if (value < MAX_NUMS) {
        obj->exists[value] = true;
        if (value > obj->maxVal) obj->maxVal = value;
    }
}

int** summaryRangesGetIntervals(SummaryRanges* obj, int* returnSize, int** returnColumnSizes) {
    int** intervals = (int**)malloc(MAX_NUMS * sizeof(int*));
    *returnColumnSizes = (int*)malloc(MAX_NUMS * sizeof(int));
    *returnSize = 0;
    
    if (obj->maxVal == -1) return intervals;
    
    int start = -1, end = -1;
    for (int i = 0; i <= obj->maxVal; i++) {
        if (obj->exists[i]) {
            if (start == -1) {
                start = end = i;
            } else if (i == end + 1) {
                end = i;
            } else {
                intervals[*returnSize] = (int*)malloc(2 * sizeof(int));
                intervals[*returnSize][0] = start;
                intervals[*returnSize][1] = end;
                (*returnColumnSizes)[*returnSize] = 2;
                (*returnSize)++;
                start = end = i;
            }
        }
    }
    
    if (start != -1) {
        intervals[*returnSize] = (int*)malloc(2 * sizeof(int));
        intervals[*returnSize][0] = start;
        intervals[*returnSize][1] = end;
        (*returnColumnSizes)[*returnSize] = 2;
        (*returnSize)++;
    }
    
    return intervals;
}

void parseArray(char* line, char operations[][20], int* opCount) {
    char* p = line;
    *opCount = 0;
    
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (!*p) return;
    p++; // skip '['
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\n')) p++;
        if (*p == ']') break;
        
        if (*p == '"') {
            p++; // skip opening quote
            int i = 0;
            while (*p && *p != '"' && i < 19) {
                operations[*opCount][i++] = *p++;
            }
            operations[*opCount][i] = '\0';
            if (*p == '"') p++; // skip closing quote
            (*opCount)++;
        }
    }
}

void parseValues(char* line, int values[], int* valCount) {
    char* p = line;
    *valCount = 0;
    
    // Find the opening bracket
    while (*p && *p != '[') p++;
    if (!*p) return;
    p++; // skip '['
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == '\n')) p++;
        if (*p == ']') break;
        
        if (strncmp(p, "null", 4) == 0) {
            values[*valCount] = -999999; // sentinel for null
            p += 4;
            (*valCount)++;
        } else if (*p >= '0' && *p <= '9') {
            values[*valCount] = 0;
            while (*p >= '0' && *p <= '9') {
                values[*valCount] = values[*valCount] * 10 + (*p - '0');
                p++;
            }
            (*valCount)++;
        } else {
            p++;
        }
    }
}

int main() {
    char line1[2000], line2[2000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    char operations[100][20];
    int values[100];
    int opCount, valCount;
    
    parseArray(line1, operations, &opCount);
    parseValues(line2, values, &valCount);
    
    SummaryRanges* obj = NULL;
    printf("[");
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "SummaryRanges") == 0) {
            obj = summaryRangesCreate();
            printf("null");
        } else if (strcmp(operations[i], "addNum") == 0) {
            summaryRangesAddNum(obj, values[i]);
            printf("null");
        } else if (strcmp(operations[i], "getIntervals") == 0) {
            int returnSize;
            int* returnColumnSizes;
            int** intervals = summaryRangesGetIntervals(obj, &returnSize, &returnColumnSizes);
            
            printf("[");
            for (int j = 0; j < returnSize; j++) {
                if (j > 0) printf(",");
                printf("[%d,%d]", intervals[j][0], intervals[j][1]);
            }
            printf("]");
            
            // Free allocated memory
            for (int j = 0; j < returnSize; j++) {
                free(intervals[j]);
            }
            free(intervals);
            free(returnColumnSizes);
        }
    }
    
    printf("]\n");
    
    if (obj) free(obj);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each getIntervals call requires sorting all n numbers

✓ Linear Growth

Space Complexity

O(n)

Set stores all unique numbers seen

⚡ Linearithmic Space

78.4K Views

Medium-High Frequency

~25 min Avg. Time

1.5K 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 - Rebuild Intervals — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler