Codestin Search App

Count Integers in Intervals - Problem

Imagine you're a booking system manager for a popular venue. You need to keep track of time slots that are reserved and quickly answer: "How many time units are currently booked?"

Your task is to implement a CountIntervals data structure that efficiently manages overlapping intervals and counts unique integers across all intervals.

The Challenge:

add(left, right) - Reserve a new time interval [left, right] (inclusive)
count() - Return total unique time units that are reserved

Key Insight: When intervals overlap, they should be merged automatically to avoid double-counting. For example, intervals [1,3] and [2,5] should be treated as [1,5] containing 5 unique integers.

Example: Adding [2,3] and [4,5] gives count=4, then adding [6,7] gives count=6. But if we add [5,6], it merges [4,5] and [6,7] into [4,7], keeping count=6.

Input & Output

example_1.py — Basic Operations

$ Input: CountIntervals() obj.add(2, 3) obj.add(4, 5) obj.count() # Returns 4 obj.add(6, 7) obj.count() # Returns 6

› Output: 4 6

💡 Note: After adding [2,3] and [4,5], we have 4 integers: {2,3,4,5}. Adding [6,7] gives us 2 more integers: {6,7}, for a total of 6.

example_2.py — Interval Merging

$ Input: CountIntervals() obj.add(2, 3) obj.add(4, 5) obj.add(6, 7) obj.count() # Returns 6 obj.add(5, 6) # Merges [4,5], [5,6], [6,7] obj.count() # Returns 6 (not 8!)

› Output: 6 6

💡 Note: The intervals [4,5], [5,6], and [6,7] all merge into [4,7] containing 4 integers. Combined with [2,3], total is still 6.

example_3.py — Large Merge

$ Input: CountIntervals() obj.add(1, 3) obj.add(5, 8) obj.add(10, 12) obj.count() # Returns 10 obj.add(3, 10) # Big merge! obj.count() # Returns 12

› Output: 10 12

💡 Note: Initially we have [1,3], [5,8], [10,12] = 3+4+3 = 10 integers. Adding [3,10] merges everything into [1,12] = 12 integers total.

Constraints

1 ≤ left ≤ right ≤ 10⁹
At most 10⁵ calls to add and count
Important: Intervals are inclusive on both ends
The total count will never exceed 2 × 10⁸

Visualization

Tap to expand

Understanding the Visualization

Add Reservation [2,4]

Guest books rooms 2, 3, 4 for one night = 3 room-nights

Add Reservation [6,8]

Another guest books rooms 6, 7, 8 = 3 more room-nights, total = 6

Add Reservation [4,6]

New guest books rooms 4, 5, 6 - this connects the previous bookings!

Smart Merge

System automatically merges into one block [2,8] = 7 room-nights total

Key Takeaway

🎯 Key Insight: Maintain sorted, non-overlapping intervals with incremental count updates. This gives us O(1) count queries and efficient interval merging for optimal performance.

Asked in

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

This problem requires an efficient interval management system. The optimal approach uses sorted intervals with binary search to maintain non-overlapping intervals and track the count incrementally. Key insights: merge overlapping intervals automatically, use binary search for O(log n) insertion, and maintain a running total count for O(1) queries.

Common Approaches

Approach	Time	Space	Notes
✓ Sorted Intervals with Binary Search	O(n)	O(n)	Maintain sorted non-overlapping intervals and use binary search for efficient insertion
Brute Force (Store All Intervals)	O(n log n)	O(n)	Store all intervals in a list and recompute merged intervals on each count() call

Sorted Intervals with Binary Search — Algorithm Steps

Maintain sorted list of non-overlapping intervals
Use binary search to find insertion position for new interval
Merge the new interval with all overlapping existing intervals
Update the running total count incrementally

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Position

Use binary search to find where new interval [4,6] should be inserted

Check Overlaps

Check adjacent intervals for potential merging with [4,6]

Merge Intervals

Merge overlapping intervals and update count incrementally

Maintain Sorted Order

Keep intervals sorted for future binary search operations

Code -

solution.c — C

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

typedef struct {
    int** intervals;
    int size;
    int capacity;
    int totalCount;
} CountIntervals;

CountIntervals* countIntervalsCreate() {
    CountIntervals* obj = (CountIntervals*)malloc(sizeof(CountIntervals));
    obj->capacity = 100;
    obj->intervals = (int**)malloc(obj->capacity * sizeof(int*));
    obj->size = 0;
    obj->totalCount = 0;
    return obj;
}

int binarySearchLeft(CountIntervals* obj, int target) {
    int left = 0, right = obj->size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (obj->intervals[mid][0] < target) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

void countIntervalsAdd(CountIntervals* obj, int left, int right) {
    if (obj->size == 0) {
        if (obj->size >= obj->capacity) {
            obj->capacity *= 2;
            obj->intervals = (int**)realloc(obj->intervals, obj->capacity * sizeof(int*));
        }
        obj->intervals[0] = (int*)malloc(2 * sizeof(int));
        obj->intervals[0][0] = left;
        obj->intervals[0][1] = right;
        obj->size = 1;
        obj->totalCount = right - left + 1;
        return;
    }
    
    int mergeLeft = left, mergeRight = right;
    int startIdx = binarySearchLeft(obj, left);
    int countToRemove = 0;
    
    // Check previous interval
    if (startIdx > 0 && obj->intervals[startIdx-1][1] >= left-1) {
        startIdx--;
    }
    
    // Find merge range
    int endIdx = startIdx;
    for (int i = startIdx; i < obj->size; i++) {
        int start = obj->intervals[i][0];
        int end = obj->intervals[i][1];
        if (end >= left-1 && start <= right+1) {
            if (start < mergeLeft) mergeLeft = start;
            if (end > mergeRight) mergeRight = end;
            countToRemove += end - start + 1;
            endIdx = i + 1;
        } else if (start > right+1) {
            break;
        }
    }
    
    // Update count
    int newCount = mergeRight - mergeLeft + 1;
    obj->totalCount = obj->totalCount - countToRemove + newCount;
    
    // Free old intervals
    for (int i = startIdx; i < endIdx; i++) {
        free(obj->intervals[i]);
    }
    
    // Shift intervals
    for (int i = endIdx; i < obj->size; i++) {
        obj->intervals[i - (endIdx - startIdx) + 1] = obj->intervals[i];
    }
    
    // Add new merged interval
    obj->intervals[startIdx] = (int*)malloc(2 * sizeof(int));
    obj->intervals[startIdx][0] = mergeLeft;
    obj->intervals[startIdx][1] = mergeRight;
    obj->size = obj->size - (endIdx - startIdx) + 1;
}

int countIntervalsCount(CountIntervals* obj) {
    return obj->totalCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

add() is O(n) in worst case when merging many intervals, count() is O(1)

✓ Linear Growth

Space Complexity

O(n)

Store at most n non-overlapping intervals plus running count

⚡ Linearithmic Space

67.2K Views

Medium-High Frequency

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

Sorted Intervals with Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler