Meeting Scheduler

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

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

✓ Brute Force

⏱️ Time: O(n×m) Space: O(1)

For each slot in person 1's schedule, check against every slot in person 2's schedule to find overlapping time periods that are long enough for the meeting.

Two Pointers

⏱️ Time: O(n log n + m log m) Space: O(1)

Sort both slot arrays by start time, then use two pointers to traverse both arrays simultaneously, checking for overlaps without examining every combination.

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>

void parseArray(const char* str, int arr[][2], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        int first = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        int second = (int)strtol(p, (char**)&p, 10);
        
        arr[*size][0] = first;
        arr[*size][1] = second;
        (*size)++;
        
        while (*p && *p != ']' && *p != '[') p++;
        if (*p == ']') p++;
    }
}

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() {
    char line1[1000], line2[1000];
    int duration;
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    scanf("%d", &duration);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int slots1[100][2], slots2[100][2];
    int size1, size2;
    
    parseArray(line1, slots1, &size1);
    parseArray(line2, slots2, &size2);
    
    int returnSize;
    int* result = solution(slots1, size1, slots2, size2, 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