Meeting Rooms - Practice Coding Problems

Meeting Rooms - Problem

Array Sorting Easy

Given an array of meeting time intervals where intervals[i] = [start_i, end_i], determine if a person could attend all meetings.

A person can attend all meetings if no two meetings overlap. Two meetings overlap if one starts before the other ends.

Example: If you have meetings [[0,30], [5,10], [15,20]], you cannot attend all meetings because the first meeting [0,30] overlaps with both [5,10] and [15,20].

Input & Output

Example 1 — Overlapping Meetings

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

› Output: false

💡 Note: The first meeting [0,30] overlaps with both [5,10] and [15,20]. Since meeting [0,30] runs from time 0 to 30, it conflicts with meeting [5,10] which starts at time 5 (before 30 ends).

Example 2 — Non-overlapping Meetings

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

› Output: true

💡 Note: After sorting by start time: [2,4] then [7,10]. Meeting [2,4] ends at time 4, and [7,10] starts at time 7. Since 4 < 7, there's no overlap.

Example 3 — Adjacent Meetings

$ Input: intervals = [[1,3],[3,6],[6,8]]

› Output: true

💡 Note: Meetings end exactly when the next one starts: [1,3] ends at 3, [3,6] starts at 3. This is allowed - meetings can be back-to-back without overlap.

Constraints

0 ≤ intervals.length ≤ 10⁴
intervals[i].length == 2
0 ≤ start_i < end_i ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input

Array of meeting intervals with start and end times

Process

Check if any meetings overlap in time

Output

Return true if all meetings can be attended, false otherwise

Key Takeaway

🎯 Key Insight: Sort meetings by start time, then only adjacent meetings can overlap

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is that after sorting meetings by start time, only adjacent meetings can potentially overlap. The optimal approach sorts the intervals in O(n log n) time and then checks adjacent pairs in O(n), giving us O(n log n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sort First - Optimal Solution	O(n log n)	O(1)	Sort meetings by start time, then check only adjacent meetings for overlaps
Brute Force - Check All Pairs	O(n²)	O(1)	Compare every meeting with every other meeting to check for overlaps

Sort First - Optimal Solution — Algorithm Steps

Sort intervals by start time
Iterate through sorted intervals
Check if current meeting overlaps with next meeting
If overlap found, return false; otherwise continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Start

Arrange meetings in chronological order

Check Adjacent

Only consecutive meetings can overlap

Return Result

False if any overlap, true otherwise

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *ia = (int *)a;
    int *ib = (int *)b;
    return ia[0] - ib[0];
}

bool solution(int intervals[][2], int n) {
    if (n <= 1) {
        return true;
    }
    
    // Sort intervals by start time
    qsort(intervals, n, sizeof(intervals[0]), compare);
    
    // Check adjacent meetings for overlap
    for (int i = 0; i < n - 1; i++) {
        // Current meeting ends after next meeting starts = overlap
        if (intervals[i][1] > intervals[i + 1][0]) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse 2D array manually
    int intervals[100][2];
    int n = 0;
    char *ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            sscanf(ptr, "%d,%d", &intervals[n][0], &intervals[n][1]);
            n++;
        }
        ptr++;
    }
    
    bool result = solution(intervals, n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (sorting is in-place)

✓ Linear Space

89.0K Views

High Frequency

~15 min Avg. Time

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

Sort First - Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler