Constraints

• `0 <= n <= 200000`, where `n` is the number of parties
• `len(party_windows) == len(geo_data)`
• Each `party_id` appears exactly once in each input, and the ID sets are identical
• All times are valid ISO-8601 UTC datetimes, and `start_time < end_time` for every party
• Group only by the `community` string exactly as given

Examples

Solution

def solution(party_windows, geo_data):
    from datetime import datetime, timezone

    def parse_utc(s):
        if s.endswith('Z'):
            s = s[:-1] + '+00:00'
        dt = datetime.fromisoformat(s)
        if dt.tzinfo is None:
            dt = dt.replace(tzinfo=timezone.utc)
        else:
            dt = dt.astimezone(timezone.utc)
        return dt

    def format_utc(dt):
        return dt.astimezone(timezone.utc).isoformat().replace('+00:00', 'Z')

    windows_by_id = {}
    for party_id, start_time, end_time in party_windows:
        windows_by_id[party_id] = (parse_utc(start_time), parse_utc(end_time))

    community_ranges = {}
    for party_id, _state, _county, _town, community in geo_data:
        start_dt, end_dt = windows_by_id[party_id]
        if community not in community_ranges:
            community_ranges[community] = [start_dt, end_dt]
        else:
            if start_dt < community_ranges[community][0]:
                community_ranges[community][0] = start_dt
            if end_dt > community_ranges[community][1]:
                community_ranges[community][1] = end_dt

    return {
        community: (format_utc(bounds[0]), format_utc(bounds[1]))
        for community, bounds in community_ranges.items()
    }

Time complexity: O(n), where n is the number of parties, assuming average O(1) hash map operations. Space complexity: O(n).

Hints

1. Build a hash map from `party_id` to its `(start_time, end_time)` so the join is O(1) per row.
2. For each community, keep only two values while scanning: the minimum start seen so far and the maximum end seen so far.

Constraints

• `0 <= n <= 200000`, where `n` is the number of parties
• `len(party_windows) == len(geo_data)`
• Each `party_id` appears exactly once in each input, and the ID sets are identical
• All times are valid ISO-8601 UTC datetimes, and `start_time < end_time` for every party
• Group only by the `town` string exactly as given
• Adjacent intervals (`end == next_start`) must be merged and must not contribute to idle time

Examples

Solution

def solution(party_windows, geo_data):
    from collections import defaultdict
    from datetime import datetime, timezone

    def parse_utc(s):
        if s.endswith('Z'):
            s = s[:-1] + '+00:00'
        dt = datetime.fromisoformat(s)
        if dt.tzinfo is None:
            dt = dt.replace(tzinfo=timezone.utc)
        else:
            dt = dt.astimezone(timezone.utc)
        return dt

    windows_by_id = {}
    for party_id, start_time, end_time in party_windows:
        windows_by_id[party_id] = (parse_utc(start_time), parse_utc(end_time))

    intervals_by_town = defaultdict(list)
    for party_id, _state, _county, town, _community in geo_data:
        start_dt, end_dt = windows_by_id[party_id]
        intervals_by_town[town].append((start_dt, end_dt))

    idle_hours = {}
    for town, intervals in intervals_by_town.items():
        intervals.sort(key=lambda interval: interval[0])

        current_end = intervals[0][1]
        idle_seconds = 0.0

        for start_dt, end_dt in intervals[1:]:
            if start_dt <= current_end:
                if end_dt > current_end:
                    current_end = end_dt
            else:
                idle_seconds += (start_dt - current_end).total_seconds()
                current_end = end_dt

        idle_hours[town] = idle_seconds / 3600.0

    return idle_hours

Time complexity: O(n log n) in the worst case because intervals for each town must be sorted; across all towns the total sorting cost is O(n log n). Space complexity: O(n).

Hints

1. After joining by `party_id`, collect all `(start, end)` intervals for each town in a hash map.
2. Sort each town's intervals by start time, then scan once: merge when `next_start <= current_end`; otherwise add the gap `next_start - current_end`.