Employee Free Time

Employee Free Time - Problem

We are given a list schedule of employees, which represents the working time for each employee. Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.

Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.

Note: Even though we are representing Intervals in the form [x, y], the objects inside are Intervals, not lists or arrays. For example, schedule[0][0].start = 1, schedule[0][0].end = 2, and schedule[0][0][0] is not defined. Also, we wouldn't include intervals like [5, 5] in our answer, as they have zero length.

Input & Output

Example 1 — Basic Case

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

› Output: [[4,6]]

💡 Note: Employee 1 works [1,3] and [6,10]. Employee 2 works [2,4] and [9,12]. Merging all intervals: [1,4] and [6,12]. The gap between them is [4,6].

Example 2 — Multiple Gaps

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

› Output: [[6,7]]

💡 Note: Employee 1: [1,3],[4,6]. Employee 2: [2,5],[7,9]. After merging: [1,6] and [7,9]. Free time is [6,7].

Example 3 — No Free Time

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

› Output: []

💡 Note: Employee 1 works [1,10], Employee 2 works [2,6],[8,12]. Combined coverage is [1,12] with no gaps.

Constraints

1 ≤ schedule.length ≤ 50
1 ≤ schedule[i].length ≤ 50
schedule[i][j].length == 2
0 ≤ schedule[i][j][0] < schedule[i][j][1] ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 35 a Amazon 28 M Microsoft 25

The key insight is that free time equals gaps between merged busy intervals. Best approach is Sort and Merge: flatten all intervals, sort by start time, merge overlaps, then find gaps. Time: O(n log n), Space: O(n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Time Points

⏱️ Time: O(n³) Space: O(n)

For every possible time range, check if any employee is working during that time. This approach examines all combinations of interval boundaries to find free periods.

Priority Queue (Min-Heap)

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

Use a priority queue to merge intervals efficiently by always processing the earliest available interval. This approach maintains active intervals in a heap and identifies gaps as we process them chronologically.

Sort and Merge Intervals

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

Collect all work intervals from all employees, sort them by start time, merge overlapping intervals, then find the gaps between merged intervals as free time.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int n;
    int* occupied;
    int size;
    int capacity;
} ExamRoom;

ExamRoom* examRoomCreate(int n) {
    ExamRoom* obj = (ExamRoom*)malloc(sizeof(ExamRoom));
    obj->n = n;
    obj->capacity = 10;
    obj->occupied = (int*)malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    return obj;
}

void insertSorted(ExamRoom* obj, int val) {
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->occupied = (int*)realloc(obj->occupied, obj->capacity * sizeof(int));
    }
    
    int pos = obj->size;
    for (int i = 0; i < obj->size; i++) {
        if (obj->occupied[i] > val) {
            pos = i;
            break;
        }
    }
    
    for (int i = obj->size; i > pos; i--) {
        obj->occupied[i] = obj->occupied[i-1];
    }
    obj->occupied[pos] = val;
    obj->size++;
}

int examRoomSeat(ExamRoom* obj) {
    if (obj->size == 0) {
        insertSorted(obj, 0);
        return 0;
    }
    
    int maxDist = 0;
    int bestSeat = 0;
    
    // Check seat 0
    if (obj->occupied[0] != 0) {
        int dist = obj->occupied[0];
        if (dist > maxDist) {
            maxDist = dist;
            bestSeat = 0;
        }
    }
    
    // Check gaps
    for (int i = 0; i < obj->size - 1; i++) {
        int left = obj->occupied[i];
        int right = obj->occupied[i + 1];
        if (right - left > 1) {
            int mid = (left + right) / 2;
            int dist1 = mid - left;
            int dist2 = right - mid;
            int dist = dist1 < dist2 ? dist1 : dist2;
            if (dist > maxDist) {
                maxDist = dist;
                bestSeat = mid;
            }
        }
    }
    
    // Check last seat
    if (obj->occupied[obj->size - 1] != obj->n - 1) {
        int dist = obj->n - 1 - obj->occupied[obj->size - 1];
        if (dist > maxDist) {
            maxDist = dist;
            bestSeat = obj->n - 1;
        }
    }
    
    insertSorted(obj, bestSeat);
    return bestSeat;
}

void examRoomLeave(ExamRoom* obj, int p) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->occupied[i] == p) {
            for (int j = i; j < obj->size - 1; j++) {
                obj->occupied[j] = obj->occupied[j + 1];
            }
            obj->size--;
            break;
        }
    }
}

void examRoomFree(ExamRoom* obj) {
    free(obj->occupied);
    free(obj);
}

char** parseStringArray(char* json, int* size) {
    if (strcmp(json, "[]") == 0) {
        *size = 0;
        return NULL;
    }
    
    // Simple parsing for string array
    char* content = json + 1;
    content[strlen(content) - 1] = '\0';
    
    char** result = malloc(100 * sizeof(char*));
    *size = 0;
    
    char* token = strtok(content, ",");
    while (token != NULL) {
        // Remove quotes and whitespace
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (*end == ' ' || *end == '"') end--;
        *(end + 1) = '\0';
        
        result[*size] = malloc(strlen(token) + 1);
        strcpy(result[*size], token);
        (*size)++;
        token = strtok(NULL, ",");
    }
    
    return result;
}

int** parseIntArray2D(char* json, int* outerSize, int** innerSizes) {
    if (strcmp(json, "[]") == 0) {
        *outerSize = 0;
        return NULL;
    }
    
    int** result = malloc(100 * sizeof(int*));
    *innerSizes = malloc(100 * sizeof(int));
    *outerSize = 0;
    
    char* ptr = json + 1; // Skip first [
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++; // Skip [
            
            int* arr = malloc(100 * sizeof(int));
            int count = 0;
            
            char numStr[20];
            int numIdx = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    numStr[numIdx++] = *ptr;
                } else if (*ptr == ',' || *ptr == ']') {
                    if (numIdx > 0) {
                        numStr[numIdx] = '\0';
                        arr[count++] = atoi(numStr);
                        numIdx = 0;
                    }
                }
                ptr++;
            }
            
            if (numIdx > 0) {
                numStr[numIdx] = '\0';
                arr[count++] = atoi(numStr);
            }
            
            result[*outerSize] = arr;
            (*innerSizes)[*outerSize] = count;
            (*outerSize)++;
            
            if (*ptr == ']') ptr++; // Skip ]
        }
        ptr++;
    }
    
    return result;
}

int* solution(char** commands, int commandsSize, int** inputs, int inputsSize, int* returnSize) {
    int* results = (int*)malloc(commandsSize * sizeof(int));
    *returnSize = commandsSize;
    ExamRoom* examRoom = NULL;
    
    for (int i = 0; i < commandsSize; i++) {
        if (strcmp(commands[i], "ExamRoom") == 0) {
            examRoom = examRoomCreate(inputs[i][0]);
            results[i] = -1;
        } else if (strcmp(commands[i], "seat") == 0) {
            results[i] = examRoomSeat(examRoom);
        } else if (strcmp(commands[i], "leave") == 0) {
            examRoomLeave(examRoom, inputs[i][0]);
            results[i] = -1;
        }
    }
    
    if (examRoom) examRoomFree(examRoom);
    return results;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newline
    line1[strcspn(line1, "\n")] = '\0';
    line2[strcspn(line2, "\n")] = '\0';
    
    int commandsSize;
    char** commands = parseStringArray(line1, &commandsSize);
    
    int inputsSize;
    int* innerSizes;
    int** inputs = parseIntArray2D(line2, &inputsSize, &innerSizes);
    
    int returnSize;
    int* result = solution(commands, commandsSize, inputs, inputsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        if (result[i] == -1) printf("null");
        else printf("%d", result[i]);
    }
    printf("]\n");
    
    // Cleanup
    for (int i = 0; i < commandsSize; i++) {
        free(commands[i]);
    }
    free(commands);
    
    for (int i = 0; i < inputsSize; i++) {
        free(inputs[i]);
    }
    free(inputs);
    free(innerSizes);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

Medium-High Frequency

~25 min Avg. Time

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