Employee Free Time - Practice Coding Problems

Employee Free Time - Problem

Find Common Free Time for All Employees

Imagine you're managing a team and need to schedule a meeting that works for everyone. You have each employee's working schedule as a list of time intervals, and you need to find all the time slots when everyone is free.

Given a list schedule where schedule[i] represents the working intervals for employee i, return all the common free time intervals for all employees. Each employee's intervals are non-overlapping and sorted.

Goal: Find time slots when ALL employees are simultaneously free
Input: List of employee schedules (each schedule is a list of intervals)
Output: List of intervals representing common free time

Note: Only return intervals with positive length (exclude zero-length intervals like [5,5])

Input & Output

example_1.py — Basic Case

$ Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]]

› Output: [[5,6],[7,9]]

💡 Note: Employee 1 works [1,3] and [6,7]. Employee 2 works [2,4]. Employee 3 works [2,5] and [9,12]. The common free times are [5,6] (between 5-6, no one is working) and [7,9] (between 7-9, no one is working).

example_2.py — Overlapping Schedules

$ Input: schedule = [[[1,3],[4,6]],[[2,5],[7,9]]]

› Output: [[6,7]]

💡 Note: Employee 1 works [1,3] and [4,6]. Employee 2 works [2,5] and [7,9]. The merged busy time is [1,6] and [7,9], so the only free time is [6,7].

example_3.py — No Free Time

$ Input: schedule = [[[1,10]],[[2,6],[8,10]],[[1,9]]]

› Output: []

💡 Note: Employee 1 works [1,10], Employee 2 works [2,6] and [8,10], Employee 3 works [1,9]. When we merge all intervals, we get [1,10] with no gaps, so there's no common free time.

Visualization

Tap to expand

Understanding the Visualization

Collect All Busy Times

Gather all working intervals from every employee's schedule

Sort Chronologically

Arrange all intervals by their start time to process them in order

Merge Overlapping Periods

Combine overlapping work periods to get consolidated busy times

Find the Gaps

The spaces between merged busy periods are your meeting opportunities

Key Takeaway

🎯 Key Insight: Free time exists in the gaps between merged busy intervals. By combining all schedules and finding the holes, we discover when everyone is simultaneously available.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Where n is total number of intervals. Sorting dominates the complexity

⚡ Linearithmic

Space Complexity

O(n)

Need to store all intervals and the result list

⚡ Linearithmic Space

Constraints

1 ≤ schedule.length, schedule[i].length ≤ 50
0 ≤ schedule[i][j].start < schedule[i][j].end ≤ 10⁸
Each employee's intervals are non-overlapping and sorted
Only return positive-length intervals (exclude zero-length like [5,5])

Asked in

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

The optimal approach uses a line sweep algorithm with either interval merging or priority queue. First, collect all working intervals from all employees. Then, merge overlapping intervals to get consolidated busy periods. Finally, find the gaps between merged intervals - these gaps represent the common free time when all employees are available. Time complexity is O(n log n) due to sorting, where n is the total number of intervals.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Flatten and Sort)	O(n log n)	O(n)	Collect all intervals, sort them, then find gaps between merged intervals
Priority Queue Line Sweep	O(n log n)	O(n)	Use a min-heap to process intervals in chronological order and track active employees

Brute Force (Flatten and Sort) — Algorithm Steps

Collect all intervals from all employees into a single list
Sort all intervals by their start time
Merge overlapping intervals to get consolidated busy periods
Find gaps between consecutive merged intervals
Return gaps as free time intervals

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect All Intervals

Gather all working intervals from all employees into one list

Sort by Start Time

Sort all intervals by their start time for processing

Merge Overlapping

Combine overlapping intervals to get consolidated busy periods

Find Gaps

Identify gaps between merged intervals as free time

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

int compare(const void* a, const void* b) {
    Interval* ia = (Interval*)a;
    Interval* ib = (Interval*)b;
    return ia->start - ib->start;
}

Interval* employeeFreeTime(Interval** schedule, int* scheduleSizes, int scheduleSize, int* returnSize) {
    // Count total intervals
    int totalCount = 0;
    for (int i = 0; i < scheduleSize; i++) {
        totalCount += scheduleSizes[i];
    }
    
    // Collect all intervals
    Interval* allIntervals = malloc(totalCount * sizeof(Interval));
    int idx = 0;
    for (int i = 0; i < scheduleSize; i++) {
        for (int j = 0; j < scheduleSizes[i]; j++) {
            allIntervals[idx++] = schedule[i][j];
        }
    }
    
    // Sort by start time
    qsort(allIntervals, totalCount, sizeof(Interval), compare);
    
    // Merge overlapping intervals
    Interval* merged = malloc(totalCount * sizeof(Interval));
    int mergedCount = 0;
    
    for (int i = 0; i < totalCount; i++) {
        if (mergedCount == 0 || merged[mergedCount - 1].end < allIntervals[i].start) {
            merged[mergedCount++] = allIntervals[i];
        } else {
            if (merged[mergedCount - 1].end < allIntervals[i].end) {
                merged[mergedCount - 1].end = allIntervals[i].end;
            }
        }
    }
    
    // Find gaps
    Interval* result = malloc((mergedCount - 1) * sizeof(Interval));
    *returnSize = 0;
    
    for (int i = 1; i < mergedCount; i++) {
        if (merged[i - 1].end < merged[i].start) {
            result[*returnSize].start = merged[i - 1].end;
            result[*returnSize].end = merged[i].start;
            (*returnSize)++;
        }
    }
    
    free(allIntervals);
    free(merged);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Where n is total number of intervals. Sorting dominates the complexity

⚡ Linearithmic

Space Complexity

O(n)

Need to store all intervals and the result list

⚡ Linearithmic Space

Constraints

1 ≤ schedule.length, schedule[i].length ≤ 50
0 ≤ schedule[i][j].start < schedule[i][j].end ≤ 10⁸
Each employee's intervals are non-overlapping and sorted
Only return positive-length intervals (exclude zero-length like [5,5])

52.0K Views

Medium Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Flatten and Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler