Meeting Rooms - Practice Coding Problems

Meeting Rooms - Problem

Array Sorting Easy

Imagine you're a busy professional trying to organize your calendar for the day. You have a list of meeting time intervals and need to determine if you can attend all meetings without any conflicts.

Given an array intervals where intervals[i] = [start_i, end_i] represents the start and end times of meeting i, return true if you can attend all meetings, or false if there are any overlapping meetings.

Goal: Check if any two meetings overlap in time.
Input: Array of meeting intervals (each interval has start and end time)
Output: Boolean value indicating if all meetings can be attended

Two meetings overlap if one starts before the other ends. For example, meetings [1,3] and [2,4] overlap because meeting 2 starts at time 2, which is before meeting 1 ends at time 3.

Input & Output

example_1.py — No conflicts

$ Input: intervals = [[0,30],[5,10],[15,20]]

› Output: false

💡 Note: The second meeting [5,10] overlaps with the first meeting [0,30] because it starts at time 5, which is before the first meeting ends at time 30. Similarly, [15,20] also overlaps with [0,30].

example_2.py — Sequential meetings

$ Input: intervals = [[7,10],[2,4]]

› Output: true

💡 Note: These two meetings do not overlap. The first meeting [2,4] ends at time 4, and the second meeting [7,10] starts at time 7, so there's no conflict.

example_3.py — Edge case touching

$ Input: intervals = [[1,5],[5,8],[8,12]]

› Output: true

💡 Note: These meetings are back-to-back but don't overlap. The first ends exactly when the second starts, which is allowed since you can attend consecutive meetings.

Visualization

Tap to expand

Understanding the Visualization

Unsorted Chaos

Meetings are given in random order, making conflicts hard to spot

Sort by Start Time

Arrange meetings chronologically like a proper schedule

Linear Conflict Check

Check each meeting against the previous one for overlaps

Immediate Detection

Stop as soon as we find any overlap and return false

Key Takeaway

🎯 Key Insight: After sorting meetings by start time, we only need to check consecutive meetings for overlaps, dramatically reducing the number of comparisons needed!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n) for checking consecutive meetings = O(n log n) overall

⚡ Linearithmic

Space Complexity

O(1)

If we can sort in-place, otherwise O(n) for creating a sorted copy

✓ Linear Space

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i < end_i ≤ 10⁶
Each interval represents a valid meeting time

Asked in

G Google 48 a Amazon 35 ⊞ Microsoft 28 f Meta 22 Apple 18

The optimal solution uses sorting to arrange meetings chronologically, then performs a single linear scan to check consecutive meetings for overlaps. Key insight: after sorting by start time, overlaps can only occur between adjacent meetings, reducing the problem from O(n²) to O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Linear Scan (Optimal)	O(n log n)	O(1)	Sort meetings by start time, then check consecutive meetings for overlaps
Brute Force (Compare All Pairs)	O(n²)	O(1)	Check every pair of meetings to see if they overlap

Sorting + Linear Scan (Optimal) — Algorithm Steps

Sort the intervals by their start times
Iterate through sorted intervals from the second meeting
For each meeting, check if it starts before the previous meeting ends
If overlap found, return false; otherwise continue
If no overlaps found after checking all meetings, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Start Time

Arrange meetings in chronological order

Check Adjacent Pairs

Compare each meeting with the previous one

Detect Overlap

If current start < previous end, there's overlap

Linear Scan Complete

Process all meetings in one pass

Code -

solution.c — C

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

int compareIntervals(const void* a, const void* b) {
    int* intervalA = *(int**)a;
    int* intervalB = *(int**)b;
    return intervalA[0] - intervalB[0];
}

bool canAttendMeetings(int** intervals, int n) {
    if (n == 0) return true;
    
    // Sort intervals by start time
    qsort(intervals, n, sizeof(int*), compareIntervals);
    
    // Check consecutive meetings for overlaps
    for (int i = 1; i < n; i++) {
        // If current meeting starts before previous meeting ends
        if (intervals[i][0] < intervals[i-1][1]) {
            return false;
        }
    }
    
    return true;
}

int main() {
    int interval1[] = {0, 30};
    int interval2[] = {5, 10};
    int interval3[] = {15, 20};
    int* intervals[] = {interval1, interval2, interval3};
    printf("%s\n", canAttendMeetings(intervals, 3) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting + O(n) for checking consecutive meetings = O(n log n) overall

⚡ Linearithmic

Space Complexity

O(1)

If we can sort in-place, otherwise O(n) for creating a sorted copy

✓ Linear Space

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i < end_i ≤ 10⁶
Each interval represents a valid meeting time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sorting + Linear Scan (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler