0933EasyMathStringSimulation

Which Light Is Showing

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A signal runs on a fixed cycle of sixty seconds: it shows green for the first thirty seconds, then amber for the next five, then red for the remaining twenty-five, and then begins again.

The cycle starts at second 0 with green just coming on. Given timer, the number of seconds since then, return which light is showing: "green", "amber" or "red".

Examples

Example 1

Input: timer = 34
Output: "amber"

Thirty-four seconds in, the green ended at thirty and the amber runs to thirty-five, so the amber is showing.

Example 2

Input: timer = 1000
Output: "red"

A thousand seconds is forty seconds into a later cycle, which falls in the red stretch.

Example 3

Input: timer = 148
Output: "green"

A hundred and forty-eight seconds is twenty-eight into a later cycle, so the green is still showing.

Constraints

0 <= timer <= 1000

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def traffic_signal(timer: int) -> str:

Java

public String trafficSignal(int timer)

The intended approach

Time O(1): one division and two comparisons.Space O(1).

The cycle repeats every sixty seconds, so only the position within the current cycle matters, which is the remainder of `timer` on division by sixty. The three stretches then take the first thirty seconds, the next five and the last twenty-five, so two comparisons on that remainder name the light. Note the boundaries: at a remainder of exactly thirty the amber has just come on, and at exactly thirty-five the red has.

Pythonentry point: traffic_signal

def traffic_signal(timer):
    at = timer % 60
    if at < 30:
        return "green"
    if at < 35:
        return "amber"
    return "red"

The obvious version

Step forward one second at a time from the start of the cycle, moving through the three stretches in turn and starting over at the end, and report whichever stretch the count lands in. Costs a step per second rather than one division.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

def bf_traffic_signal(timer):
    order = ["green"] * 30 + ["amber"] * 5 + ["red"] * 25
    at = 0
    for _ in range(timer):
        at += 1
        if at == len(order):
            at = 0
    return order[at]

How this problem was checked

Reference solution executed against 13 test cases — 13 passed
3 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in