LeetCode 3894 - Traffic Signal Color

Difficulty: 🟢 Easy
Topics: —

Solution

Problem Understanding

This problem asks us to determine the current state of a traffic signal based on an integer timer that represents the remaining seconds for the signal. The rules for the signal are strictly defined: if the timer is 0, the signal shows "Green"; if it is exactly 30, the signal shows "Orange"; if it is greater than 30 but at most 90, the signal shows "Red". Any other value of the timer is considered invalid, and the function should return "Invalid".

The input timer is guaranteed to be between 0 and 1000. This range tells us the input is small enough that a straightforward conditional check is sufficient, and we do not need to optimize for large inputs. The edge cases to consider include exactly hitting the boundary values (0, 30, 90) and values just outside these boundaries (1, 29, 91, 1000) which should return "Invalid".

The problem guarantees a single integer input, and the output is a string representing the signal color. There are no complicated data structures or iterative computations required.

Approaches

A brute-force approach would be to check every possible value from 0 to 1000 and manually map each to a color. This would work, but it is unnecessary and tedious. Given the clearly defined discrete ranges, a simple sequence of conditional checks can directly determine the correct output.

The key insight is that since the rules are based purely on numeric ranges and exact matches, a small sequence of if-elif-else statements is sufficient to cover all cases in O(1) time. No iteration or complex data structure is needed.

Approach	Time Complexity	Space Complexity	Notes
Brute Force	O(1000)	O(1)	Check each integer value individually, mapping to the output string
Optimal	O(1)	O(1)	Direct conditional checks for the defined ranges

Algorithm Walkthrough

Check if timer equals 0. If so, return "Green". This directly handles the first rule and is the simplest case.
If timer equals 30, return "Orange". This handles the second exact-match condition.
If timer is greater than 30 but less than or equal to 90, return "Red". This handles the continuous range for the red signal.
If none of the above conditions are met, return "Invalid". This captures all out-of-range or undefined values.

Why it works: Each conditional check corresponds exactly to the problem's rules. The order of checks ensures that exact matches are prioritized before the range check for "Red". Any value not covered by the first three conditions cannot be a valid timer, ensuring the "Invalid" result is correct.

Python Solution

class Solution:
    def trafficSignal(self, timer: int) -> str:
        if timer == 0:
            return "Green"
        elif timer == 30:
            return "Orange"
        elif 30 < timer <= 90:
            return "Red"
        else:
            return "Invalid"

The implementation follows the algorithm step by step. First, it checks for the exact value 0 for green. Next, it checks for the exact value 30 for orange. Then, it checks if the timer falls in the continuous range (30, 90] for red. Any other input falls into the else clause, returning "Invalid".

Go Solution

func trafficSignal(timer int) string {
    if timer == 0 {
        return "Green"
    } else if timer == 30 {
        return "Orange"
    } else if timer > 30 && timer <= 90 {
        return "Red"
    } else {
        return "Invalid"
    }
}

The Go implementation mirrors the Python logic. It uses simple if-else statements. There is no need for slices, maps, or complex data structures. Integer comparisons are sufficient, and there is no risk of overflow within the given constraints.

Worked Examples

Example 1: timer = 60

Step	Condition	Result
1	timer == 0	False
2	timer == 30	False
3	30 < timer <= 90	True
4	Return	"Red"

Example 2: timer = 5

Step	Condition	Result
1	timer == 0	False
2	timer == 30	False
3	30 < timer <= 90	False
4	Return	"Invalid"

Example 3: timer = 0

Step	Condition	Result
1	timer == 0	True
2	Return	"Green"

Example 4: timer = 30

Step	Condition	Result
1	timer == 0	False
2	timer == 30	True
3	Return	"Orange"

Complexity Analysis

Measure	Complexity	Explanation
Time	O(1)	Only a constant number of conditional checks are performed
Space	O(1)	No additional data structures are used, only a few local variables

The reasoning is straightforward: the solution does not iterate or allocate significant memory. Each input triggers a sequence of simple checks, so the runtime and memory usage are constant.

Test Cases

solution = Solution()

# Provided examples
assert solution.trafficSignal(60) == "Red"  # mid-range red
assert solution.trafficSignal(5) == "Invalid"  # outside defined range

# Boundary cases
assert solution.trafficSignal(0) == "Green"  # lower boundary for green
assert solution.trafficSignal(30) == "Orange"  # exact orange
assert solution.trafficSignal(90) == "Red"  # upper boundary for red
assert solution.trafficSignal(91) == "Invalid"  # just above red
assert solution.trafficSignal(1000) == "Invalid"  # maximum input

# Edge cases around 30
assert solution.trafficSignal(29) == "Invalid"  # just below orange
assert solution.trafficSignal(31) == "Red"  # just above orange

Test	Why
60	mid-range red, normal case
5	invalid, below defined ranges
0	exact lower boundary, green
30	exact match for orange
90	upper boundary for red
91	just above valid red range, invalid
1000	maximum input, invalid
29	just below orange, invalid
31	just above orange, red

Edge Cases

One edge case is when the timer is exactly 0. This is important because a naive > 0 check could incorrectly classify it. The implementation handles it first with an exact equality check. Another edge case is when the timer is exactly 30, which must return "Orange" instead of falling into the "Red" range. This is handled with an exact equality check before the range check. A final edge case is when the timer exceeds the valid red range, e.g., 91 or even the maximum allowed 1000. These values must correctly return "Invalid", and the final else clause ensures they are handled properly.