三台机器同时生产，最早第几秒够七件？

"""Independent machines start at t=0; positive integer seconds per item."""
from itertools import product


def require(condition, message):
    if not condition:
        raise AssertionError(message)


def min_time(periods, target, emit=None):
    """Earliest integer time when total completed items >= target.

    periods: nonempty list/tuple of positive int values, excluding bool.
    target: nonnegative int, excluding bool. Validate even when target is zero.
    Inputs are not changed; observers must not mutate periods.
    """
    if not isinstance(periods, (list, tuple)) or not periods:
        raise ValueError("a nonempty list or tuple of machine periods is required")
    if any(type(k) is not int or k <= 0 for k in periods):
        raise ValueError("each period must be a positive int, not bool")
    if type(target) is not int or target < 0:
        raise ValueError("target must be a nonnegative int, not bool")
    if target == 0:
        return 0

    lo = 0  # Infeasible: positive target, zero completed items.
    hi = min(periods) * target  # Feasible: the fastest machine alone suffices.
    while hi - lo > 1:
        mid = lo + (hi - lo) // 2
        completed = sum(mid // k for k in periods)
        if emit is not None:
            emit(lo, hi, mid, completed)
        if completed >= target:
            hi = mid  # This works, but an earlier time may also work.
        else:
            lo = mid  # This and all earlier times cannot work.
    return hi


def ticking_oracle(periods, target):
    """Small-test reference: advance each machine's countdown one second.

    No binary search and no time // period production formula are used here.
    Only called with known-valid small inputs.
    """
    remaining = list(periods)
    completed = seconds = 0
    while completed < target:
        seconds += 1
        for index, period in enumerate(periods):
            remaining[index] -= 1
            if remaining[index] == 0:
                completed += 1
                remaining[index] = period
    return seconds


def main():
    periods, target = [3, 2, 5], 7
    trace = []
    answer = min_time(periods, target, lambda lo, hi, mid, count: trace.append((lo, hi, mid, count)))
    require(answer == 8 and ticking_oracle(periods, target) == 8, "official model example")
    print(f"periods={periods}; target={target}; guaranteed_upper={min(periods) * target}")
    for lo, hi, mid, count in trace:
        print(f"lo={lo}; hi={hi}; mid={mid}; completed={count}; feasible={count >= target}")
    print(f"answer={answer}; at_7={[7 // k for k in periods]}; at_8={[8 // k for k in periods]}")
    jump = min_time([2, 2], 3)
    require(jump == 4, "must accept >= target when count jumps over it")
    require(min_time([3, 2, 5], 0) == 0, "zero items")
    print(f"jump_periods=[2, 2]; target=3; answer={jump}; completed=4; zero_target=0")

    machine_lists = cases = 0
    for n in range(1, 5):
        for periods in product(range(1, 6), repeat=n):
            machine_lists += 1
            previous = -1
            for target in range(21):
                answer = min_time(periods, target)
                wanted = ticking_oracle(periods, target)
                require(answer == wanted, f"oracle mismatch: {periods}, {target}")
                require(answer >= previous, "more requested items finished earlier")
                previous = answer
                cases += 1
    require(machine_lists == 780 and cases == 16380, "enumeration coverage")

    large_target = 10**40
    require(min_time([7], large_target) == 7 * large_target, "large single-machine integer")
    period, target = 10**30 + 7, 2 * 10**20 + 1
    require(min_time([period, period], target) == period * ((target + 1) // 2), "large simultaneous events")
    order_cases = 0
    for periods in ([3, 2, 5], [1, 5, 3, 2], [5, 5, 2, 1]):
        before = list(periods)
        for target in (0, 1, 7, 20):
            require(min_time(periods, target) == min_time(periods[::-1], target), "machine order matters")
            order_cases += 1
        require(periods == before, "input mutated")

    invalid = [([], 0), ([], 1), ([0], 1), ([-2], 1), ([1.5], 1), ([True], 1),
               (None, 1), ("23", 1), (iter([2, 3]), 1), ([[2]], 1),
               ([2], -1), ([2], True), ([2], 1.0), ([2], "7")]
    rejected = 0
    for periods, target in invalid:
        try:
            min_time(periods, target)
        except ValueError:
            rejected += 1
        else:
            raise AssertionError("invalid input accepted")
    print(f"machine_lists={machine_lists}; target_cases={cases}; huge_integer_cases=2; order_cases={order_cases}")
    print(f"rejected_inputs={rejected}; validates_configuration_before_zero_target=True")
    print("PASS: minimum times match ticking oracle; model has no startup/shared-resource limits")


if __name__ == "__main__":
    main()