Design a Meeting Scheduler / Calendar

import bisect
import threading
from typing import List, Tuple, Optional

class Meeting:
    def __init__(self, start: int, end: int, title: str):
        self.start = start
        self.end = end
        self.title = title

class Room:
    def __init__(self, room_id: str):
        self.room_id = room_id
        self.bookings: List[Tuple[int, int, Meeting]] = []  # Keep sorted by start time
        self.lock = threading.Lock()

    def book(self, meeting: Meeting) -> bool:
        with self.lock:
            # Binary search neighbor index using bisect
            idx = bisect.bisect_left(self.bookings, (meeting.start, meeting.end))
            
            # Check overlap with previous booking (if any)
            if idx > 0:
                prev_start, prev_end, _ = self.bookings[idx - 1]
                if prev_end > meeting.start:
                    return False  # Overlap!
                    
            # Check overlap with next booking (if any)
            if idx < len(self.bookings):
                next_start, next_end, _ = self.bookings[idx]
                if meeting.end > next_start:
                    return False  # Overlap!
                    
            # Insert into sorted list
            self.bookings.insert(idx, (meeting.start, meeting.end, meeting))
            return True

class Scheduler:
    def __init__(self):
        self.rooms: List[Room] = []
        self.lock = threading.Lock()

    def add_room(self, room_id: str):
        with self.lock:
            self.rooms.append(Room(room_id))

    def book_meeting(self, meeting: Meeting) -> Optional[str]:
        # Try booking in rooms
        for room in self.rooms:
            if room.book(meeting):
                return room.room_id
        return None

import java.util.*;
import java.util.concurrent.locks.ReentrantLock;

class Meeting {
    int start;
    int end;
    String title;
    Meeting(int s, int e, String t) {
        this.start = s;
        this.end = e;
        this.title = t;
    }
}

class Room {
    String roomId;
    // TreeMap keeps entries sorted by start time, allowing ceiling/floor log(N) operations
    private final TreeMap<Integer, Meeting> bookings = new TreeMap<>();
    private final ReentrantLock lock = new ReentrantLock();

    Room(String id) { this.roomId = id; }

    public boolean book(Meeting meeting) {
        lock.lock();
        try {
            // Find booking starting immediately at or after meeting.start
            Integer nextStart = bookings.ceilingKey(meeting.start);
            if (nextStart != null && nextStart < meeting.end) {
                return false; // Overlaps with next meeting
            }
            // Find booking starting before meeting.start
            Integer prevStart = bookings.floorKey(meeting.start);
            if (prevStart != null) {
                Meeting prevMeeting = bookings.get(prevStart);
                if (prevMeeting.end > meeting.start) {
                    return false; // Overlaps with previous meeting
                }
            }
            bookings.put(meeting.start, meeting);
            return true;
        } finally {
            lock.unlock();
        }
    }
}

public class Scheduler {
    private final List<Room> rooms = new ArrayList<>();
    private final ReentrantLock lock = new ReentrantLock();

    public void addRoom(String roomId) {
        lock.lock();
        try {
            rooms.add(new Room(roomId));
        } finally {
            lock.unlock();
        }
    }

    public String bookMeeting(Meeting meeting) {
        for (Room room : rooms) {
            if (room.book(meeting)) {
                return room.roomId;
            }
        }
        return null; // No available room fits this interval
    }
}

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <mutex>
#include <memory>

class Meeting {
public:
    int start;
    int end;
    std::string title;
    Meeting(int s, int e, std::string t) : start(s), end(e), title(t) {}
};

class Room {
private:
    std::string roomId;
    // Map in C++ is a red-black tree, sorted by key (start time)
    std::map<int, std::shared_ptr<Meeting>> bookings;
    std::mutex mtx;
public:
    Room(std::string id) : roomId(id) {}

    std::string getRoomId() const { return roomId; }

    bool book(std::shared_ptr<Meeting> meeting) {
        std::lock_guard<std::mutex> lock(mtx);
        
        // Find iterator pointing to first element >= meeting->start
        auto it = bookings.lower_bound(meeting->start);
        if (it != bookings.end() && it->first < meeting->end) {
            return false; // Overlap with next meeting
        }
        if (it != bookings.begin()) {
            auto prevIt = std::prev(it);
            if (prevIt->second->end > meeting->start) {
                return false; // Overlap with previous meeting
            }
        }
        
        bookings[meeting->start] = meeting;
        return true;
    }
};

class Scheduler {
private:
    std::vector<std::shared_ptr<Room>> rooms;
    std::mutex mtx;
public:
    void addRoom(const std::string& id) {
        std::lock_guard<std::mutex> lock(mtx);
        rooms.push_back(std::make_shared<Room>(id));
    }

    std::string bookMeeting(std::shared_ptr<Meeting> meeting) {
        for (auto& room : rooms) {
            if (room->book(meeting)) {
                return room->getRoomId();
            }
        }
        return "";
    }
};

type Meeting = { start: number; end: number };

class Scheduler {
  // Each room holds bookings sorted by start time.
  private rooms: Meeting[][] = [];

  private overlaps(a: Meeting, b: Meeting) {
    return a.start < b.end && b.start < a.end;   // half-open intervals
  }

  // Book into the first room with no conflict; open a new room if none fits.
  book(m: Meeting): number {
    for (let i = 0; i < this.rooms.length; i++) {
      if (!this.rooms[i].some((b) => this.overlaps(b, m))) {
        this.rooms[i].push(m);
        return i;                                 // assigned room index
      }
    }
    this.rooms.push([m]);                          // all busy → new room
    return this.rooms.length - 1;
  }
}