0885EasyHash TableString

Runner-Up Digit on a Tag

Tracked in this browser only

Trains the technique from

LeetCode 1796Second Largest Digit in a String

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 tag reads s, a mix of lowercase letters and digits.

Return the second largest digit appearing on the tag, counting each distinct digit once however often it appears. Return -1 when the tag has fewer than two distinct digits.

Examples

Example 1

Input: s = "crate84bin37"
Output: 7

The digits on the tag are 8, 4, 3 and 7. The largest is 8, so the runner-up is 7.

Example 2

Input: s = "zzz5zzz5zzz2"
Output: 2

Only two distinct digits appear, 5 and 2, however often each is repeated, so the runner-up is 2.

Example 3

Input: s = "shelf7"
Output: -1

The tag holds a single distinct digit, so there is no runner-up.

Constraints

1 <= s.length <= 500
s consists of lowercase English letters and digits only

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 second_highest(s: str) -> int:

Java

public int secondHighest(String s)

The intended approach

Time O(n) for a tag of length n, one pass.Space O(1): two running values.

Only the two largest distinct digits matter, so there is no need to keep the rest. Carry two values through one pass: the largest digit seen and the largest seen that is strictly smaller than it. Each digit read either beats the leader, in which case the old leader becomes the runner-up, or sits between the two and becomes the runner-up itself. A digit equal to either is ignored, which is what makes repeats harmless. Letters are skipped. If no runner-up was ever set, the tag had fewer than two distinct digits.

Pythonentry point: second_highest

def second_highest(s):
    top = -1
    second = -1
    for ch in s:
        if not ("0" <= ch <= "9"):
            continue
        d = ord(ch) - 48
        if d > top:
            second = top
            top = d
        elif d < top and d > second:
            second = d
    return second

The obvious version

Collect the digits into a list, drop the repeats, sort what is left, and read off the second from the end. Sorts the whole collection rather than tracking two values.

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_second_highest(s):
    seen = []
    for ch in s:
        if "0" <= ch <= "9":
            d = ord(ch) - 48
            if d not in seen:
                seen.append(d)
    seen.sort()
    if len(seen) < 2:
        return -1
    return seen[-2]

How this problem was checked

Reference solution executed against 11 test cases — 11 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