Code Logo

Harbor Radio Digit Masking

Published at22 Apr 2026
Created by
Python String Handling Medium 0 views
Like0

A harbor radio log is shared with external partners, but some of the numeric identifiers inside each message need partial masking before the text leaves the operations room. The policy is simple to state but slightly awkward to implement: keep only the last three digits that appear anywhere in the message, and replace every earlier digit with *. Non-digit characters must stay exactly as they are.

The masking rule is based on the total digit sequence, not on separate number groups. That means you have to think about all digits in the message together. For example, "Dock 12 -> Crane 9087" contains the digits 1, 2, 9, 0, 8, 7. The last three are 0, 8, 7, so the masked result should be "Dock ** -> Crane *087".

If a message contains three digits or fewer, nothing should be hidden. A text like "Gate 404" stays "Gate 404". If there are no digits at all, the original message should come back unchanged.

This makes the task more than a quick replacement. Whether a digit should stay visible depends on how many digits appear later in the string, so the solution needs a little bookkeeping before it can decide what to mask.

Example Input & Output

Example 1
Input
message = "Dock 12 -> Crane 9087"
Output
"Dock ** -> Crane *087"
Explanation

Only the final three digits in the whole message remain visible.

Example 2
Input
message = "Gate 404"
Output
"Gate 404"
Explanation

There are only three digits total, so nothing is masked.

Example 3
Input
message = "All clear"
Output
"All clear"
Explanation

A message with no digits should be returned unchanged.

Algorithm Flow

Recommendation Algorithm Flow for Harbor Radio Digit Masking
Recommendation Algorithm Flow for Harbor Radio Digit Masking

Solution Approach

The main challenge here is that you cannot decide whether to hide a digit just by looking at that single character in isolation. A digit is visible only if it belongs to the last three digits in the whole message. That means the code needs global context.

One clean way to handle that is with two passes. In the first pass, count how many digits appear in the message. In the second pass, walk through the characters again and decide, for each digit, whether it falls before or inside the final three-digit window.

That logic can be written like this:

total_digits = sum(1 for ch in message if ch.isdigit())
seen = 0
result = []

for ch in message:
    if ch.isdigit():
        seen += 1
        if seen <= total_digits - 3:
            result.append("*")
        else:
            result.append(ch)
    else:
        result.append(ch)

return "".join(result)

The variable seen tracks how many digits have already been processed from left to right. If the current digit still lies before the final three, it becomes *. Otherwise it stays visible. Because non-digit characters are copied straight into the result, the message keeps its original punctuation, spacing, arrows, and labels.

You could also solve the same problem from right to left by reversing through the string and keeping the first three digits you encounter in that direction. That approach works too, but the two-pass left-to-right version is often easier to read because the masking rule is spelled out directly using counts.

So the key idea is not a special string method. It is recognizing that the masking decision depends on the total number of digits in the message, which naturally pushes the solution toward counting plus conditional rebuilding. That is what gives this challenge its medium difficulty: the string is still simple, but the decision rule reaches beyond one character at a time.

Best Answers

python - Approach 1
def mask_radio_digits(message):
    keep = 3
    result = list(message)
    for i in range(len(message) - 1, -1, -1):
        if message[i].isdigit():
            if keep > 0:
                keep -= 1
            else:
                result[i] = "*"
    return "".join(result)