Count Integers in Intervals - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each count() call requires sorting n intervals and merging them

⚡ Linearithmic

Space Complexity

O(n)

Store all n intervals in memory

⚡ Linearithmic Space

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⁸

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
✓ 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	O(n)	O(n)	Maintain sorted non-overlapping intervals and use binary search for efficient insertion

Brute Force (Store All Intervals) — Algorithm Steps

Store each added interval in a list
On count(): sort all intervals by start time
Merge overlapping intervals in one pass
Sum the lengths of merged intervals

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Intervals

Store each interval [2,3], [6,7], [1,2] in a list

Sort on Count

Sort by start time: [1,2], [2,3], [6,7]

Merge Overlaps

Merge [1,2] and [2,3] into [1,3], keep [6,7]

Sum Lengths

Count = (3-1+1) + (7-6+1) = 3 + 2 = 5

Code -

solution.c — C

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

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

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

void countIntervalsAdd(CountIntervals* obj, int left, int right) {
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->intervals = (int**)realloc(obj->intervals, obj->capacity * sizeof(int*));
    }
    obj->intervals[obj->size] = (int*)malloc(2 * sizeof(int));
    obj->intervals[obj->size][0] = left;
    obj->intervals[obj->size][1] = right;
    obj->size++;
}

int compare(const void* a, const void* b) {
    int* ia = *(int**)a;
    int* ib = *(int**)b;
    return ia[0] - ib[0];
}

int countIntervalsCount(CountIntervals* obj) {
    if (obj->size == 0) return 0;
    
    // Create sorted copy
    int** sorted = (int**)malloc(obj->size * sizeof(int*));
    for (int i = 0; i < obj->size; i++) {
        sorted[i] = (int*)malloc(2 * sizeof(int));
        sorted[i][0] = obj->intervals[i][0];
        sorted[i][1] = obj->intervals[i][1];
    }
    qsort(sorted, obj->size, sizeof(int*), compare);
    
    // Merge and count
    int total = sorted[0][1] - sorted[0][0] + 1;
    int lastEnd = sorted[0][1];
    
    for (int i = 1; i < obj->size; i++) {
        if (sorted[i][0] <= lastEnd + 1) {
            if (sorted[i][1] > lastEnd) {
                total += sorted[i][1] - lastEnd;
                lastEnd = sorted[i][1];
            }
        } else {
            total += sorted[i][1] - sorted[i][0] + 1;
            lastEnd = sorted[i][1];
        }
    }
    
    // Cleanup
    for (int i = 0; i < obj->size; i++) {
        free(sorted[i]);
    }
    free(sorted);
    
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each count() call requires sorting n intervals and merging them

⚡ Linearithmic

Space Complexity

O(n)

Store all n intervals in memory

⚡ Linearithmic Space

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⁸

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Store All Intervals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler