Example 1
ready- Input
intervals = [ [ 0, 30 ], [ 5, 10 ], [ 15, 20 ] ]- Expected
false- Why
- the 5–10 meeting starts while 0–30 is still running
Meeting Rooms
25 min · canAttendMeetings()Calendars get awkward the moment one minute is promised to two meetings.
You're given intervals, where each [start, end] pair describes one meeting. Return
true when one person can attend every meeting, or false when any two meetings
overlap.
A few ground rules:
- A meeting occupies time from
startup to, but not including,end. - One meeting may end exactly when another begins.
[0, 5]and[5, 10]don't overlap. - A meeting with
start == endoccupies no time, so it can't clash with another meeting. - An empty calendar is conflict-free and returns
true.
Constraints
0 <= intervals.length <= 100_000- Every interval contains exactly two integers:
[start, end]. 0 <= start <= end <= 1_000_000_000
Hints
Start with pairs
Pick two meetings and ask whether the later start happens before the earlier end. Checking every pair is a correct baseline. How many checks does 100,000 meetings create?
Put the calendar in order
Sort meetings by start time. Once they're chronological, a conflict has nowhere to hide far away from the meeting that came just before it.
One strict comparison
After sorting, compare each non-empty meeting's start with the previous non-empty
meeting's end. Use <, not <=, because touching endpoints are allowed.
Follow-up
If the answer is false, could you return one conflicting pair of meetings as well?
Visible cases
Examples
Example 2
ready- Input
intervals = [ [ 7, 10 ], [ 2, 4 ] ]- Expected
true- Why
- the meetings occupy separate stretches of time
Example 3
ready- Input
intervals = []- Expected
true- Why
- an empty calendar has no conflict
Interview signal
Asked at
AmazonGoogleMeta
Check every pair
Two meetings overlap when the later start is strictly earlier than the earlier end. Compare every pair and stop as soon as you find that condition. Zero-duration meetings need an explicit skip because they occupy no time.
def can_attend_meetings(intervals: list[list[int]]) -> bool:
for i in range(len(intervals) - 1):
first_start, first_end = intervals[i]
if first_start == first_end:
continue
for j in range(i + 1, len(intervals)):
second_start, second_end = intervals[j]
if second_start == second_end:
continue
later_start = max(first_start, second_start)
earlier_end = min(first_end, second_end)
if later_start < earlier_end:
return False
return TrueTime O(n²) — every pair may need a comparison. Space O(1).
Sort and scan
Sort the non-empty meetings by start time. Now a meeting only needs to pass one test: does it begin before the preceding meeting ends? If so, those two overlap. If every adjacent pair passes, no earlier meeting can still be running without having already overlapped the meeting after it.
def can_attend_meetings(intervals: list[list[int]]) -> bool:
meetings = sorted(
(start, end) for start, end in intervals if start < end
)
for i in range(1, len(meetings)):
if meetings[i][0] < meetings[i - 1][1]:
return False
return TrueThe strict < carries the endpoint rule: a start equal to the previous end is safe.
Filtering zero-duration meetings keeps an instant inside a longer meeting from looking
like a real conflict.
Time O(n log n) for sorting, followed by one linear scan. Space O(n) for the sorted copy.
Loading editor
Console
ready to runReady to run.
3 cases are queued.
Visible testcase
Case 1
Expected
false
Run: visible + custom · Submit: full suite