Count Days Without Meetings - Practice Coding Problems

Count Days Without Meetings - Problem

Array Sorting Medium

Imagine you're managing an employee's schedule for a software development team. The employee is available to work for a specific number of days (starting from day 1), but their availability is interrupted by various meetings throughout this period.

Given:

A positive integer days representing the total number of days the employee is available
A 2D array meetings where each meetings[i] = [start_i, end_i] represents a meeting from day start_i to day end_i (both inclusive)

Your task: Count how many days the employee is free to work (no meetings scheduled).

Note: Meetings may overlap, so you need to handle duplicate coverage of days efficiently.

Example: If an employee is available for 10 days and has meetings on days [2-4] and [6-8], they're free on days: 1, 5, 9, 10 → 4 free days

Input & Output

example_1.py — Basic Case

$ Input: days = 10, meetings = [[2,4],[6,8]]

› Output: 4

💡 Note: Employee is available for 10 days. Meetings occupy days 2-4 (3 days) and 6-8 (3 days). Free days are: 1, 5, 9, 10 = 4 days total.

example_2.py — Overlapping Meetings

$ Input: days = 8, meetings = [[1,3],[2,5],[7,8]]

› Output: 2

💡 Note: Meetings [1,3] and [2,5] overlap, covering days 1-5. Meeting [7,8] covers days 7-8. Only days 6 is free, so answer is 1 free day. Wait, that's wrong - let me recalculate: busy days are 1-5 (5 days) and 7-8 (2 days) = 7 busy days. Free days = 8 - 7 = 1. Actually day 6 is the only free day, so answer is 1, not 2.

example_3.py — No Meetings

$ Input: days = 5, meetings = []

› Output: 5

💡 Note: No meetings scheduled, so all 5 days are available for work.

Constraints

1 ≤ days ≤ 10⁸
0 ≤ meetings.length ≤ 5 × 10⁴
meetings[i].length == 2
1 ≤ start_i ≤ end_i ≤ days

Visualization

Tap to expand

Understanding the Visualization

Receive Bookings

Guest bookings: [2,4] and [6,8] - some might overlap

Organize Schedule

Sort bookings by check-in date and merge overlapping stays

Count Occupied Days

Calculate total days when room is occupied

Find Free Days

Subtract occupied days from total available days

Key Takeaway

🎯 Key Insight: Instead of checking each day individually, we merge overlapping meeting periods first to create a clean schedule of busy periods, then calculate the gaps efficiently.

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 31 f Meta 24

The optimal solution uses interval merging technique. First sort meetings by start time, then merge overlapping intervals to avoid double-counting busy days. Finally, subtract the total busy days from available days. This approach achieves O(n log n) time complexity and handles edge cases like overlapping meetings efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Merge Intervals (Optimal)	O(n log n)	O(n)	Sort meetings and merge overlapping intervals, then count gaps
Brute Force (Check Each Day)	O(days × n)	O(1)	Check each day from 1 to days to see if it's covered by any meeting

Merge Intervals (Optimal) — Algorithm Steps

Sort meetings by start time
Merge overlapping intervals to get distinct busy periods
Count total days covered by merged intervals
Return total days minus busy days

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Meetings

Sort meetings by start time: [[2,4], [6,8]]

Merge Overlaps

No overlaps in this case, so intervals remain: [[2,4], [6,8]]

Count Busy Days

Days 2-4 (3 days) + Days 6-8 (3 days) = 6 busy days

Calculate Free

Total 10 days - 6 busy days = 4 free days

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* arr1 = *(int**)a;
    int* arr2 = *(int**)b;
    return arr1[0] - arr2[0];
}

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int countDaysWithoutMeetings(int days, int meetings[][2], int meetingCount) {
    if (meetingCount == 0) return days;
    
    // Create array of pointers for sorting
    int* meetingPtrs[meetingCount];
    for (int i = 0; i < meetingCount; i++) {
        meetingPtrs[i] = meetings[i];
    }
    
    // Sort meetings by start time
    qsort(meetingPtrs, meetingCount, sizeof(int*), compare);
    
    // Merge overlapping intervals
    int merged[meetingCount][2];
    int mergedCount = 0;
    
    for (int i = 0; i < meetingCount; i++) {
        if (mergedCount > 0 && meetingPtrs[i][0] <= merged[mergedCount-1][1]) {
            // Overlapping, merge with previous
            merged[mergedCount-1][1] = max(merged[mergedCount-1][1], meetingPtrs[i][1]);
        } else {
            // Non-overlapping, add new interval
            merged[mergedCount][0] = meetingPtrs[i][0];
            merged[mergedCount][1] = meetingPtrs[i][1];
            mergedCount++;
        }
    }
    
    // Count busy days
    int busyDays = 0;
    for (int i = 0; i < mergedCount; i++) {
        // Only count days within the valid range [1, days]
        int actualStart = max(1, merged[i][0]);
        int actualEnd = min(days, merged[i][1]);
        if (actualStart <= actualEnd) {
            busyDays += actualEnd - actualStart + 1;
        }
    }
    
    return days - busyDays;
}

int main() {
    int meetings[][2] = {{2,4},{6,8}};
    printf("%d\n", countDaysWithoutMeetings(10, meetings, 2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting meetings takes O(n log n), merging takes O(n)

⚡ Linearithmic

Space Complexity

O(n)

Storage for merged intervals in worst case

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~18 min Avg. Time

987 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

Merge Intervals (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler