Meeting Scheduler - Practice Coding Problems

Meeting Scheduler - Problem

Meeting Scheduler is a classic interval scheduling problem that simulates real-world calendar coordination.

You're given two people's availability schedules as arrays of time slots and need to find the earliest time slot where both can meet for a specified duration.

Input:
• slots1: First person's available time slots as [start, end] pairs
• slots2: Second person's available time slots as [start, end] pairs
• duration: Required meeting length

Output:
• Return the [start, end] of the earliest valid meeting slot
• Return [] if no valid slot exists

Example: If person A is free [[10,50],[60,120]] and person B is free [[0,15],[60,70]] for a 8-minute meeting, the answer is [60,68] - the earliest overlapping slot that fits the duration.

Input & Output

example_1.py — Basic Overlap

$ Input: slots1 = [[10,50],[60,120],[140,210]] slots2 = [[0,15],[60,70]] duration = 8

› Output: [60,68]

💡 Note: The earliest overlap is between [60,120] and [60,70], giving us [60,70]. Since we need 8 minutes and have 10 minutes available, we can schedule from 60 to 68.

example_2.py — No Valid Meeting

$ Input: slots1 = [[10,50],[60,120],[140,210]] slots2 = [[0,15],[60,70]] duration = 12

› Output: []

💡 Note: The only overlap [60,70] has duration 10, which is less than required 12 minutes. No valid meeting slot exists.

example_3.py — Multiple Overlaps

$ Input: slots1 = [[10,60],[120,200]] slots2 = [[20,30],[40,50],[180,250]] duration = 8

› Output: [20,28]

💡 Note: Multiple overlaps exist: [20,30] and [40,50] with first slot, [180,200] with second slot. The earliest valid meeting starts at 20.

Constraints

1 ≤ slots1.length, slots2.length ≤ 10⁴
slots1[i].length = slots2[i].length = 2
slots1[i][0] < slots1[i][1]
slots2[i][0] < slots2[i][1]
0 ≤ slots1[i][j], slots2[i][j] ≤ 10⁹
1 ≤ duration ≤ 10⁶
No overlapping slots within same person's schedule

Visualization

Tap to expand

Understanding the Visualization

Setup Pointers

Place one pointer on each person's first available slot

Check Overlap

See if current slots from both people overlap sufficiently

Move Forward

Advance the pointer whose slot ends earlier to find next potential overlap

Return Result

When we find sufficient overlap, schedule the meeting at the earliest possible time

Key Takeaway

🎯 Key Insight: By using two pointers and advancing the one with the earlier end time, we efficiently find overlaps without checking all combinations, reducing time complexity from O(n*m) to O(n+m).

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a two-pointer technique to efficiently find the earliest meeting slot in O(n+m) time. By leveraging the sorted nature of the input intervals, we can traverse both arrays simultaneously and check for overlaps without examining all possible combinations, making it much faster than the brute force O(n*m) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*m)	O(1)	Check every slot from person 1 against every slot from person 2
Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to efficiently scan through both sorted slot arrays

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each slot in slots1
For each slot1, iterate through each slot in slots2
Calculate overlap between slot1 and slot2
Check if overlap duration >= required duration
Track the earliest valid meeting start time
Return the earliest meeting slot or empty array

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare All Pairs

Check each slot1 against every slot2

Find Overlap

Calculate intersection of time intervals

Check Duration

Verify if overlap can fit meeting duration

Track Earliest

Keep track of earliest valid meeting time

Code -

solution.c — C

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

int* earliestMeeting(int** slots1, int slots1Size, int** slots2, int slots2Size, int duration, int* returnSize) {
    int earliestStart = INT_MAX;
    int* result = malloc(2 * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < slots1Size; i++) {
        for (int j = 0; j < slots2Size; j++) {
            // Find overlap
            int start = (slots1[i][0] > slots2[j][0]) ? slots1[i][0] : slots2[j][0];
            int end = (slots1[i][1] < slots2[j][1]) ? slots1[i][1] : slots2[j][1];
            
            // Check if overlap can fit the meeting
            if (end - start >= duration) {
                if (start < earliestStart) {
                    earliestStart = start;
                    result[0] = start;
                    result[1] = start + duration;
                    *returnSize = 2;
                }
            }
        }
    }
    
    return result;
}

int main() {
    // Input parsing and function call would be implemented here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

We check every slot in slots1 (n) against every slot in slots2 (m)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

42.0K Views

High Frequency

~18 min Avg. Time

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler