Getting Oriented

We want to count weekdays (Monday through Friday) in a date range, skipping any holidays we're given. The core insight is that we don't need to loop over every single day if we think about weeks as units, but let's first nail down the straightforward approach, then discuss the optimization.

Clarifying the Boundaries

Before writing any code, let's settle on a few things:

Is the range inclusive on both ends? We'll assume yes: both start_date and end_date count if they're business days.
What if start equals end? If it's a weekday and not a holiday, the answer is 1. If it's a weekend, the answer is 0.
What if start is after end? We'll return 0 (or raise, depending on the contract).
Holiday format: We'll accept a list of date objects and store them in a set for O(1) lookup.

The Naive Approach: Loop Day by Day

The simplest thing is to walk from start to end, one day at a time, and count anything that's a weekday and not a holiday.

from datetime import date, timedelta

def business_day_count(start: date, end: date, holidays: list[date] = None) -> int:
    if start > end:
        return 0

    holiday_set = set(holidays) if holidays else set()
    count = 0
    current = start

    while current <= end:
        # weekday() returns 0=Monday, 6=Sunday
        if current.weekday() < 5 and current not in holiday_set:
            count += 1
        current += timedelta(days=1)

    return count

This is correct and easy to reason about. The time complexity is O(n + h) where n is the number of days in the range and h is the number of holidays (for building the set). For small ranges this is fine, but if someone asks for business days over a 50-year span, we'd prefer something faster.

The Faster Approach: Week Math

The key observation is that every complete 7-day week contains exactly 5 business days. So we can compute the count in O(1) (before accounting for holidays) by doing arithmetic on weeks and remainders.

Let's think through it step by step:

Calculate the total number of days: total_days = (end - start).days + 1
Full weeks contribute exactly 5 weekdays each.
The remaining days (0 to 6 leftover days) need careful handling because we don't know which day of the week they land on without checking.

A cleaner formulation that avoids edge case headaches is to count weekdays using the offset from Monday. If we know how many days have passed since the most recent Monday for both start and end, we can figure out how many weekdays are in the interval directly.

from datetime import date, timedelta

def business_day_count(start: date, end: date, holidays: list[date] = None) -> int:
    if start > end:
        return 0

    holiday_set = set(holidays) if holidays else set()

    # Count weekdays using week math
    # Shift the range to start from a Monday boundary
    start_offset = start.weekday()  # 0=Mon, 4=Fri, 5=Sat, 6=Sun
    end_offset = end.weekday()

    # Total days including both endpoints
    total_days = (end - start).days + 1

    # Total full weeks
    full_weeks = total_days // 7
    remaining_days = total_days % 7

    # Weekdays in full weeks
    count = full_weeks * 5

    # For the remaining days, we need to know which days of the week they cover.
    # They start on the same weekday as `start`. We count how many of those
    # remaining days fall on Mon-Fri.
    for i in range(remaining_days):
        day_of_week = (start_offset + i) % 7
        if day_of_week < 5:  # Mon=0 through Fri=4
            count += 1

    # Subtract holidays that fall within the range on weekdays
    for h in holiday_set:
        if start <= h <= end and h.weekday() < 5:
            count -= 1

    return count

The loop over remaining_days runs at most 6 times, so the weekday counting itself is O(1). The holiday subtraction is O(h) where h is the number of holidays. Overall this is O(h), much better for large date ranges.

Walking Through an Example

Let's trace through a concrete case. Say start = 2024-01-01 (Monday) and end = 2024-01-12 (Friday), no holidays.

total_days = 12
full_weeks = 1, contributing 5 weekdays
remaining_days = 5
start_offset = 0 (Monday), so remaining days cover Mon, Tue, Wed, Thu, Fri. All 5 are weekdays.
Total: 5 + 5 = 10. Correct, two full work weeks.

Now add a holiday on 2024-01-08 (Monday). It's within the range and is a weekday, so we subtract 1. Result: 9.

Bonus: Using NumPy for Bulk Operations

If you're working in a data science context or need to compute this for thousands of date pairs, NumPy's busday_count is purpose-built for this and handles holidays natively.

import numpy as np

count = np.busday_count('2024-01-01', '2024-01-13', holidays=['2024-01-08'])
# Note: np.busday_count is exclusive on the end date, so we pass end + 1 day
# to match our inclusive convention

Worth knowing it exists in an interview, but you'd still want to explain the underlying algorithm.

Edge Cases Worth Mentioning

Start and end on weekends: The algorithm handles this correctly because start_offset of 5 or 6 shifts the day-of-week math appropriately.
Holiday on a weekend: We explicitly check h.weekday() < 5 before subtracting, so Saturday/Sunday holidays don't affect the count.
Duplicate holidays: Using a set deduplicates them automatically.
Empty range (start > end): Returns 0 immediately.

Complexity Summary

Time: O(h) where h is the number of holidays provided.
Space: O(h) to store the holiday set.
The naive approach is O(n + h) which is fine for small ranges but degrades for multi-year spans.

2163. Business Day Count

Similar Questions