Time Slot Scheduler - Problem

You are building a meeting scheduler application. Given a list of meeting time slots represented as [start, end] intervals, you need to:

1. Find all free time slots during a standard workday (9 AM to 5 PM, represented as [9, 17])

2. Detect any double-bookings (overlapping meetings)

Return a result object containing:

freeSlots: Array of [start, end] intervals representing free time
conflicts: Array of [start, end] intervals representing overlapping meetings

Note: All times are represented as integers (9 = 9 AM, 17 = 5 PM, etc.)

Input & Output

Example 1 — Basic Scheduling

$ Input: meetings = [[10,12],[11,13],[14,15]]

› Output: {"freeSlots":[[9,10],[13,14],[15,17]],"conflicts":[[11,12]]}

💡 Note: Meeting [11,13] overlaps with [10,12] from 11-12. Free time exists before 10, between 13-14, and after 15.

Example 2 — No Conflicts

$ Input: meetings = [[9,10],[11,12],[14,16]]

› Output: {"freeSlots":[[10,11],[12,14],[16,17]],"conflicts":[]}

💡 Note: All meetings are separate with no overlaps. Free slots exist in the gaps between meetings.

Example 3 — Multiple Conflicts

$ Input: meetings = [[10,14],[11,13],[12,15]]

› Output: {"freeSlots":[[9,10],[15,17]],"conflicts":[[11,13],[12,14]]}

💡 Note: Three-way overlap: [11,13] conflicts with [10,14], and [12,15] conflicts with both previous meetings.

Constraints

0 ≤ meetings.length ≤ 100
meetings[i].length == 2
0 ≤ start_i < end_i ≤ 24
Workday is defined as [9, 17] (9 AM to 5 PM)

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 35 f Meta 28

The key insight is to sort meetings by start time, enabling efficient detection of overlaps and gaps in a single pass. Best approach uses sorting + merging to process meetings chronologically. Time: O(n log n), Space: O(k) where k is the number of result intervals.

Common Approaches

✓ Brute Force Comparison

⏱️ Time: O(n²) Space: O(k)

Compare each meeting with every other meeting to find conflicts. Then check each hour of the workday against all meetings to find free time.

Sort Then Process

⏱️ Time: O(n log n) Space: O(k)

Sort meetings chronologically, then walk through them once to find overlapping meetings and gaps representing free time.

Brute Force Comparison — Algorithm Steps

Check every pair of meetings for overlaps (O(n²) comparisons)
For each hour from 9 to 17, check if any meeting covers it
Collect overlapping intervals and free time slots

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Pairs

Check every meeting against every other meeting for overlaps

Check Hours

Test each hour 9-17 against all meetings to find free time

Collect Results

Gather all conflicts and free slots found

Code -

solution.c — C

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

#define MAX_MEETINGS 100
#define MAX_RESULT 50

typedef struct {
    int start, end;
} Interval;

typedef struct {
    Interval freeSlots[MAX_RESULT];
    int freeCount;
    Interval conflicts[MAX_RESULT];
    int conflictCount;
} Result;

Result solution(Interval meetings[], int n) {
    Result result = {0};
    
    // Find conflicts by comparing all pairs
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int start1 = meetings[i].start, end1 = meetings[i].end;
            int start2 = meetings[j].start, end2 = meetings[j].end;
            
            // Check for overlap
            if (start1 < end2 && start2 < end1) {
                int overlapStart = (start1 > start2) ? start1 : start2;
                int overlapEnd = (end1 < end2) ? end1 : end2;
                
                // Check if already exists
                bool exists = false;
                for (int k = 0; k < result.conflictCount; k++) {
                    if (result.conflicts[k].start == overlapStart && result.conflicts[k].end == overlapEnd) {
                        exists = true;
                        break;
                    }
                }
                if (!exists) {
                    result.conflicts[result.conflictCount].start = overlapStart;
                    result.conflicts[result.conflictCount].end = overlapEnd;
                    result.conflictCount++;
                }
            }
        }
    }
    
    // Find free slots by checking each hour
    int workdayStart = 9, workdayEnd = 17;
    for (int hour = workdayStart; hour < workdayEnd; hour++) {
        bool isFree = true;
        for (int i = 0; i < n; i++) {
            if (meetings[i].start <= hour && hour < meetings[i].end) {
                isFree = false;
                break;
            }
        }
        if (isFree) {
            // Extend free slot if consecutive
            if (result.freeCount > 0 && result.freeSlots[result.freeCount-1].end == hour) {
                result.freeSlots[result.freeCount-1].end = hour + 1;
            } else {
                result.freeSlots[result.freeCount].start = hour;
                result.freeSlots[result.freeCount].end = hour + 1;
                result.freeCount++;
            }
        }
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse meetings array
    Interval meetings[MAX_MEETINGS];
    int n = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++; // Skip first [
        while (*ptr && n < MAX_MEETINGS) {
            if (*ptr == '[') {
                ptr++;
                int start = atoi(ptr);
                while (*ptr && *ptr != ',') ptr++;
                if (*ptr == ',') ptr++;
                int end = atoi(ptr);
                meetings[n].start = start;
                meetings[n].end = end;
                n++;
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            } else {
                ptr++;
            }
        }
    }
    
    Result result = solution(meetings, n);
    
    printf("{\"freeSlots\":[");
    for (int i = 0; i < result.freeCount; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result.freeSlots[i].start, result.freeSlots[i].end);
    }
    printf("],\"conflicts\":[");
    for (int i = 0; i < result.conflictCount; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result.conflicts[i].start, result.conflicts[i].end);
    }
    printf("]}
");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops to compare all meeting pairs, plus checking each time slot

⚠ Quadratic Growth

Space Complexity

O(k)

Space for storing conflicts and free slots (k = number of result intervals)

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

894 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

Time Slot Scheduler - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler