My Calendar I

My Calendar I - Problem

Array Binary Search Design Segment Tree Ordered Set Medium

You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a double booking.

A double booking happens when two events have some non-empty intersection (i.e., some moment is common to both events).

The event can be represented as a pair of integers startTime and endTime that represents a booking on the half-open interval [startTime, endTime), the range of real numbers x such that startTime <= x < endTime.

Implement the MyCalendar class:

MyCalendar() Initializes the calendar object.
boolean book(int startTime, int endTime) Returns true if the event can be added to the calendar successfully without causing a double booking. Otherwise, return false and do not add the event to the calendar.

Input & Output

Example 1 — Basic Calendar Operations

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

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

💡 Note: MyCalendar() initializes calendar. book(10,20) returns true (first booking). book(15,25) returns false (overlaps with [10,20)). book(20,30) returns true (no overlap since [10,20) ends at 20).

Example 2 — Adjacent Bookings

$ Input: commands = ["MyCalendar", "book", "book"], parameters = [[], [10, 20], [20, 30]]

› Output: [null, true, true]

💡 Note: book(10,20) succeeds. book(20,30) succeeds because intervals [10,20) and [20,30) don't overlap (20 is not included in first interval).

Example 3 — Multiple Overlaps

$ Input: commands = ["MyCalendar", "book", "book", "book", "book"], parameters = [[], [5, 10], [25, 30], [15, 20], [12, 18]]

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

💡 Note: First three bookings succeed. book(12,18) fails because it overlaps with [15,20): max(12,15) < min(18,20) → 15 < 18 is true.

Constraints

0 ≤ start < end ≤ 10⁹
At most 1000 calls will be made to book

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 10 🍎 Apple 8

The key insight is that two intervals [a,b) and [c,d) overlap if max(a,c) < min(b,d). The linear search approach checks all existing bookings for overlap in O(n) time. For better performance, use binary search on sorted bookings to find insertion position quickly. Time: O(n), Space: O(n)

Common Approaches

✓ Linear Search

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

For each booking request, iterate through all existing bookings to check if there's any overlap. If no overlap found, add the new booking.

Sorted List with Binary Search

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

Maintain bookings in sorted order by start time. Use binary search to quickly find where a new booking would fit and check only adjacent bookings for overlap.

Linear Search — Algorithm Steps

Store all bookings in a list
For each new booking, check against all existing bookings
If no overlap found, add the booking and return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Existing Bookings

List of current bookings

Check Overlap

Compare new booking with each existing one

Add or Reject

Add if no overlap, reject otherwise

Code -

solution.c — C

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

#define MAX_BOOKINGS 1000
#define MAX_COMMANDS 1000
#define MAX_LINE 10000

// --- Calendar Logic ---

typedef struct {
    int bookings[MAX_BOOKINGS][2];
    int size;
} MyCalendar;

MyCalendar* myCalendarCreate() {
    MyCalendar* obj = (MyCalendar*)malloc(sizeof(MyCalendar));
    if (obj) {
        obj->size = 0;
    }
    return obj;
}

bool myCalendarBook(MyCalendar* obj, int start, int end) {
    if (!obj) return false;

    // Check for intersection with existing bookings
    for (int i = 0; i < obj->size; i++) {
        int s = obj->bookings[i][0];
        int e = obj->bookings[i][1];
        
        // Intersection formula: max(start1, start2) < min(end1, end2)
        int maxStart = (start > s) ? start : s;
        int minEnd = (end < e) ? end : e;
        
        if (maxStart < minEnd) {
            return false;
        }
    }
    
    // Add new booking
    if (obj->size < MAX_BOOKINGS) {
        obj->bookings[obj->size][0] = start;
        obj->bookings[obj->size][1] = end;
        obj->size++;
        return true;
    }
    return false;
}

// --- Parsing Logic ---

static char commands[MAX_COMMANDS][20];
static int parameters[MAX_COMMANDS][2];
static char results[MAX_COMMANDS][10];

void parseCommands(char* str, int* cmdCount) {
    *cmdCount = 0;
    char* p = str;
    
    while (*p) {
        // Find opening quote
        if (*p == '"') {
            p++; // Move past '"'
            char* start = p;
            
            // Find closing quote
            while (*p && *p != '"') {
                p++;
            }
            
            if (*p == '"') {
                *p = '\0'; // Temporarily terminate string to copy
                if (*cmdCount < MAX_COMMANDS) {
                    strcpy(commands[*cmdCount], start);
                    (*cmdCount)++;
                }
                *p = '"'; // Restore if needed (not strictly necessary here)
                p++;
            }
        } else {
            p++;
        }
    }
}

void parseParameters(char* str, int* paramCount) {
    *paramCount = 0;
    char* p = str;
    
    // Find the start of the outer array
    char* outerStart = strchr(p, '[');
    if (!outerStart) return;
    p = outerStart + 1;

    while (*p) {
        // Find start of an inner array definition '['
        if (*p == '[') {
            p++;
            
            // check for empty array "[]"
            while (isspace(*p)) p++;
            
            if (*p == ']') {
                // Empty parameter set
                parameters[*paramCount][0] = 0;
                parameters[*paramCount][1] = 0;
                (*paramCount)++;
                p++;
            } else {
                // Parse first number
                int val1 = (int)strtol(p, &p, 10);
                
                // Skip comma/spaces
                while (*p && (isspace(*p) || *p == ',')) p++;
                
                // Parse second number
                int val2 = (int)strtol(p, &p, 10);
                
                if (*paramCount < MAX_COMMANDS) {
                    parameters[*paramCount][0] = val1;
                    parameters[*paramCount][1] = val2;
                    (*paramCount)++;
                }
                
                // Move to closing bracket
                while (*p && *p != ']') p++;
                if (*p == ']') p++;
            }
        } else {
            p++;
        }
    }
}

// --- Main Execution ---

int main() {
    char line[MAX_LINE];
    int cmdCount = 0; 
    int paramCount = 0;

    // Read Commands
    if (!fgets(line, MAX_LINE, stdin)) return 0;
    parseCommands(line, &cmdCount);

    // Read Parameters
    if (!fgets(line, MAX_LINE, stdin)) return 0;
    parseParameters(line, &paramCount);

    MyCalendar* calendar = NULL;

    // Process
    for (int i = 0; i < cmdCount; i++) {
        if (strcmp(commands[i], "MyCalendar") == 0) {
            calendar = myCalendarCreate();
            strcpy(results[i], "null");
        } else if (strcmp(commands[i], "book") == 0) {
            if (calendar) {
                int start = parameters[i][0];
                int end = parameters[i][1];
                bool result = myCalendarBook(calendar, start, end);
                strcpy(results[i], result ? "true" : "false");
            } else {
                strcpy(results[i], "false");
            }
        }
    }

    // Output
    printf("[");
    for (int i = 0; i < cmdCount; i++) {
        if (i > 0) printf(",");
        printf("%s", results[i]);
    }
    printf("]\n");

    // Cleanup
    if (calendar) free(calendar);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each book operation checks all existing bookings

✓ Linear Growth

Space Complexity

O(n)

Store all bookings in a list

⚡ Linearithmic Space

98.5K Views

Medium Frequency

~15 min Avg. Time

2.2K 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

Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler