0293HardString

Reading Token Validator

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 field logger writes one token per line and you are asked to sieve out the malformed ones. A token is a valid reading exactly when it can be cut into a body, optionally followed by a scale part, with nothing left over.

A body is an optional single + or -, followed by one of these three shapes:

one or more digits;
one or more digits, then ., then zero or more digits;
., then one or more digits.

A scale part is the letter e or E, then an optional single + or -, then one or more digits.

Any other letter, a second ., a second e or E, a sign that is neither at the very start nor directly after e or E, or a . sitting inside the scale part all make the token invalid. Decide it by inspecting the characters; do not hand the token to a built-in numeric conversion.

Given token, return true when it is a valid reading and false otherwise.

Examples

Example 1

Input: token = "+3e-2"
Output: true

The body is +3, which is a sign followed by one digit, and the scale part is e-2, which is the marker, a sign and one digit.

Example 2

Input: token = "46.e3"
Output: true

The body 46. is digits followed by a dot with no digits after it, which the second shape allows, and e3 is a well-formed scale part.

Example 3

Input: token = "2e4.1"
Output: false

The dot falls inside the scale part, where only a sign and digits may appear.

Constraints

1 <= token.length <= 20
token consists of only English letters (both uppercase and lowercase), digits (0-9), plus '+', minus '-', or dot '.'.

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 is_valid_reading(token: str) -> bool:

Java

public boolean isValidReading(String token)

The intended approach

Time O(n)Space O(1)

Sweep the token once, carrying whether a digit has been seen, whether the dot is spent, whether the scale marker is spent, and whether a digit has followed that marker. A sign is only tolerated at index 0 or straight after the marker, a dot is refused once the marker is out, and the marker itself is refused before any digit. After the sweep the token needs at least one digit overall and, if a marker appeared, at least one digit behind it.

Pythonentry point: is_valid_reading

def is_valid_reading(token):
    # One left-to-right scan carrying four facts: whether any digit has been seen,
    # whether the dot has been used, whether the exponent marker has been used, and
    # whether a digit has appeared after that marker.
    # O(n) time, O(1) space.
    seen_digit = False
    seen_dot = False
    seen_marker = False
    digit_after_marker = False
    for i, ch in enumerate(token):
        if ch == "+" or ch == "-":
            if i > 0 and token[i - 1] not in "eE":
                return False
        elif ch in "0123456789":
            seen_digit = True
            if seen_marker:
                digit_after_marker = True
        elif ch == ".":
            if seen_dot or seen_marker:
                return False
            seen_dot = True
        elif ch == "e" or ch == "E":
            if seen_marker or not seen_digit:
                return False
            seen_marker = True
        else:
            return False
    if not seen_digit:
        return False
    if seen_marker and not digit_after_marker:
        return False
    return True

The obvious version

Match the whole token against a compiled pattern that spells out the three body shapes and the optional scale part.

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

import re

_SHAPE = re.compile(r"[+-]?([0-9]+\.?[0-9]*|\.[0-9]+)([eE][+-]?[0-9]+)?\Z")


def bf_is_valid_reading(token):
    return _SHAPE.match(token) is not None

How this problem was checked

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