My Calendar I - Practice Coding Problems

My Calendar I - Problem

Array Binary Search Design Segment Tree Ordered Set Medium

Design a Calendar System: You're building a smart calendar application that prevents double bookings. Your task is to implement a MyCalendar class that can efficiently determine whether a new event conflicts with existing bookings.

Key Concepts:
• Events are represented as half-open intervals [startTime, endTime)
• Two events conflict if they share any moment in time
• The interval [startTime, endTime) includes startTime but excludes endTime

Example: Event [10, 20) conflicts with [15, 25) because they overlap from time 15 to 20.

Your Implementation Must Support:
• MyCalendar() - Initialize an empty calendar
• book(startTime, endTime) - Return true if the event can be booked without conflicts, false otherwise

Input & Output

example_1.py — Basic Calendar Operations

$ Input: ["MyCalendar", "book", "book", "book"] [[], [10, 20], [15, 25], [20, 30]]

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

💡 Note: MyCalendar() initializes empty calendar. book(10, 20) succeeds as calendar is empty. book(15, 25) fails because it overlaps with existing [10, 20). book(20, 30) succeeds because it starts exactly when [10, 20) ends (half-open intervals).

example_2.py — Edge Case with Adjacent Events

$ Input: ["MyCalendar", "book", "book", "book", "book"] [[], [5, 10], [10, 15], [0, 5], [15, 20]]

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

💡 Note: All bookings succeed because they are perfectly adjacent with no overlaps. [5,10) and [10,15) don't overlap since first ends at 10 and second starts at 10. Same logic applies to other adjacent pairs.

example_3.py — Multiple Overlap Attempts

$ Input: ["MyCalendar", "book", "book", "book", "book", "book"] [[], [1, 5], [2, 6], [3, 4], [1, 3], [5, 10]]

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

💡 Note: book(1,5) succeeds. book(2,6) fails (overlaps with [1,5)). book(3,4) fails (contained within [1,5)). book(1,3) fails (overlaps with [1,5)). book(5,10) succeeds (starts where [1,5) ends).

Constraints

0 ≤ start < end ≤ 10⁹
At most 1000 calls will be made to book
All time values are integers
Half-open intervals: [start, end) includes start but excludes end

Visualization

Tap to expand

Understanding the Visualization

Guest Arrival

New guest wants to book room from check-in to check-out time

Check Existing

System checks against all existing reservations for conflicts

Conflict Detection

Two reservations conflict if their time periods overlap at any point

Decision

Accept booking if no conflicts, reject if any overlap found

Key Takeaway

🎯 Key Insight: Half-open intervals [start, end) mean end time is exclusive - guests can check out at exactly the same time another checks in!

Asked in

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

The optimal approach uses a sorted list with binary search to maintain events in chronological order. For each booking request, use binary search O(log n) to find the insertion position, then check only the adjacent events for conflicts. While insertion still takes O(n) time due to array shifting, this approach significantly reduces the number of comparisons from O(n) to O(log n), making it ideal for applications with frequent booking queries.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n)	Check each new booking against all existing bookings
Sorted List + Binary Search	O(n)	O(n)	Maintain events in sorted order and use binary search for efficient conflict detection

Brute Force (Linear Search) — Algorithm Steps

Store all booked events in a simple list
For each new booking, iterate through all existing events
Check if new event overlaps with any existing event
If no overlap found, add to list and return true
If overlap found, return false without adding

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Calendar starts empty, ready to accept first booking

First Booking

Book [10,20) - no existing events, so booking succeeds

Second Booking Attempt

Try to book [15,25) - check against [10,20), find overlap, reject

Third Booking Attempt

Try to book [20,30) - check against [10,20), no overlap, accept

Code -

solution.c — C

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

#define MAX_EVENTS 1000

typedef struct {
    int events[MAX_EVENTS][2];
    int count;
} MyCalendar;

MyCalendar* myCalendarCreate() {
    MyCalendar* calendar = malloc(sizeof(MyCalendar));
    calendar->count = 0;
    return calendar;
}

int max(int a, int b) {
    return (a > b) ? a : b;
}

int min(int a, int b) {
    return (a < b) ? a : b;
}

bool myCalendarBook(MyCalendar* obj, int start, int end) {
    // Check against all existing events
    for (int i = 0; i < obj->count; i++) {
        int existingStart = obj->events[i][0];
        int existingEnd = obj->events[i][1];
        
        // Check for overlap
        if (max(start, existingStart) < min(end, existingEnd)) {
            return false;
        }
    }
    
    // No overlap found, book the event
    obj->events[obj->count][0] = start;
    obj->events[obj->count][1] = end;
    obj->count++;
    return true;
}

void myCalendarFree(MyCalendar* obj) {
    free(obj);
}

// Example usage
int main() {
    MyCalendar* calendar = myCalendarCreate();
    printf("%d\n", myCalendarBook(calendar, 10, 20)); // 1
    printf("%d\n", myCalendarBook(calendar, 15, 25)); // 0
    printf("%d\n", myCalendarBook(calendar, 20, 30)); // 1
    myCalendarFree(calendar);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each booking requires checking against all n existing events

✓ Linear Growth

Space Complexity

O(n)

Storage for n events in the calendar

⚡ Linearithmic Space

42.3K Views

High Frequency

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

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler