Find Live Hand-Off Windows Between Follow-the-Sun Support Teams

A support org staffs several regional teams, each covering its own recurring weekly shifts in its own local time. For a live hand-off between two teams to happen, both teams need to be online at the same moment. Build the planner that finds those overlap windows.

Time is tracked as an offset in minutes into a repeating week: W = 10080 (7 * 24 * 60), so minute 0 is the start of the week and minute 10079 is its last minute.

Part 1 — Overlap on a single UTC timeline

Each shift is a triple (team_id, start, end) already in UTC, with 0 <= start < end <= W. A team may have more than one shift. Find every maximal interval where two or more distinct teams have a shift covering that minute, and return those intervals as [start, end) pairs, sorted by start. Assume shifts belonging to the same team never overlap each other.

Part 2 — Local time and the week wraparound

Shifts are now given in each team's local time: (team_id, local_start, local_end, utc_offset), where utc_offset is local time minus UTC, in minutes (UTC+9 is 540, UTC-5 is -300). Converting to UTC is utc_time = local_time - utc_offset, but because the week repeats, a converted shift can land partly or wholly outside [0, W) and must be wrapped back into range — which can split one local shift into two UTC pieces straddling the week boundary. Recompute the overlap intervals from Part 1 on top of these converted, possibly-split shifts.

Part 3 — Lead time, minimum length, and a cap

def handoff_windows(now_utc: int, earliest_lag: int, min_overlap: int,
                     max_results: int, team_windows: list[tuple]) -> list[list[int]]:

From the overlap intervals computed in Part 2, keep only the ones that:

• start at or after now_utc + earliest_lag (a hand-off can't be scheduled before the team has had notice);
• last at least min_overlap minutes.

Return at most max_results of the surviving intervals, in chronological order by start.

Example

team_windows = [
    ("A", 480, 1200, 0),   # UTC team, online 08:00-20:00 Monday (minute 480-1200)
    ("B", 600, 1320, 0),   # UTC team, online 10:00-22:00 Monday
    ("C", 0, 480, 540),    # Tokyo (UTC+9) team, local 00:00-08:00 -> UTC 9540-10020
]

handoff_windows(0, 0, 60, 5, team_windows)
# -> [[600, 1200]]

Teams A and B overlap from minute 600 to 1200 (2 hours into A's shift through B's start... through to A's end); team C's converted window doesn't touch either.

Underspecified details to pin down

As with many real specs, several choices aren't fully determined by the prompt above; state and justify the ones you pick, for example: whether max_results selects the earliest windows or the longest ones, whether two teams whose online windows only touch at a single instant count as overlapping, and what happens if team_windows is empty.

Constraints

• Up to 2000 shift entries across all teams.
• 0 <= local_start < local_end <= W for every shift before conversion.
• -720 <= utc_offset <= 840 (a generous real-world time-zone range).
• 0 <= now_utc < W, 0 <= earliest_lag, 0 <= min_overlap <= W, 1 <= max_results.