Meeting Scheduler - Practice Coding Problems

Meeting Scheduler - Problem

Given the availability time slots arrays slots1 and slots2 of two people and a meeting duration, return the earliest time slot that works for both of them and is of duration duration.

If there is no common time slot that satisfies the requirements, return an empty array.

The format of a time slot is an array of two elements [start, end] representing an inclusive time range from start to end.

It is guaranteed that no two availability slots of the same person intersect with each other. That is, for any two time slots [start1, end1] and [start2, end2] of the same person, either start1 > end2 or start2 > end1.

Input & Output

Example 1 — Basic Meeting Scheduling

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

› Output: [60,68]

💡 Note: The earliest common slot is [60,70] which has length 10 ≥ 8, so we schedule the meeting from 60 to 68

Example 2 — No Common Slot

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

› Output: []

💡 Note: The only overlap [60,70] has length 10 < 12, so no meeting can be scheduled

Example 3 — Multiple Overlaps

$ Input: slots1 = [[0,20],[50,80]], slots2 = [[10,30],[70,90]], duration = 5

› Output: [10,15]

💡 Note: Two overlaps exist: [10,20] and [70,80], but [10,20] is earlier, so return [10,15]

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]
1 ≤ duration ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input

Two people's availability slots and meeting duration

Process

Find overlapping time periods with sufficient duration

Output

Earliest valid meeting slot or empty array

Key Takeaway

🎯 Key Insight: Sort time slots and use two pointers to efficiently find the earliest overlapping period with sufficient duration

Asked in

G Google 25 a Amazon 18 M Microsoft 15 F Facebook 12

The key insight is to use two pointers to efficiently scan through sorted time slots to find overlapping intervals. The optimal approach sorts both arrays and uses two pointers to find the earliest valid meeting slot. Time: O(n log n + m log m), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n×m)	O(1)	Check every slot combination between two people
Two Pointers	O(n log n + m log m)	O(1)	Use two pointers to efficiently scan sorted schedules

Brute Force — Algorithm Steps

Iterate through each slot in slots1
For each slot1, iterate through each slot in slots2
Calculate overlap and check if duration is sufficient
Return the earliest valid slot

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Each Slot

Check slot1[i] vs slot2[j] for all i,j

Find Overlap

Calculate intersection of time ranges

Check Duration

Verify overlap is long enough for meeting

Code -

solution.c — C

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

int* solution(int slots1[][2], int size1, int slots2[][2], int size2, int duration, int* returnSize) {
    int* earliest = NULL;
    *returnSize = 0;
    
    for (int i = 0; i < size1; i++) {
        for (int j = 0; j < size2; j++) {
            // Find overlap between slot1 and slot2
            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 is long enough
            if (end - start >= duration) {
                if (earliest == NULL || start < earliest[0]) {
                    if (earliest == NULL) {
                        earliest = (int*)malloc(2 * sizeof(int));
                        *returnSize = 2;
                    }
                    earliest[0] = start;
                    earliest[1] = start + duration;
                }
            }
        }
    }
    
    return earliest;
}

int main() {
    // Simplified parsing for demo
    int slots1[10][2] = {{10,50},{60,120},{140,210}};
    int slots2[10][2] = {{0,15},{60,70}};
    int duration = 8;
    int returnSize;
    
    int* result = solution(slots1, 3, slots2, 2, duration, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Nested loops through slots1 (n) and slots2 (m)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

890 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler