1070EasyHash TableTwo PointersString

Does the Reading Survive a Half Turn

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 reading is given as the string num, made only of digits.

Turning the whole reading upside down turns each digit in place and reverses their order. Only some digits survive the turn: 0, 1 and 8 turn into themselves, while 6 and 9 turn into each other. Every other digit becomes unreadable.

Return whether the reading looks exactly the same after being turned upside down.

Examples

Example 1

Input: num = "1961"
Output: true

The outer ones turn into each other, and the nine and six in the middle swap into each other, so the turned reading matches the original.

Example 2

Input: num = "25"
Output: false

The two has no turned form at all, so the reading cannot survive.

Example 3

Input: num = "0"
Output: true

A single zero turns into itself, so the reading is unchanged.

Constraints

1 <= num.length <= 50
The reading is made of digits only.
The reading has no leading zero unless it is the single digit zero.

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_strobogrammatic(num: str) -> bool:

Java

public boolean isStrobogrammatic(String num)

The intended approach

Time O(n) over the reading's length.Space O(1).

Turning the reading upside down sends the digit at one end to the other end, so the reading survives exactly when, working inwards from both ends at once, each pair of facing digits turns into the other. So close in with two markers. At each step the digit on the left must turn into the digit on the right, which the five allowed pairings settle outright; anything else and the answer is no. When the two markers meet on a single middle digit, that digit has to turn into itself, so it must be `0`, `1` or `8`. Letting the two markers meet, rather than stopping when they cross, folds the middle digit into the same check with no special case. One pass over half the reading.

Pythonentry point: is_strobogrammatic

def is_strobogrammatic(num):
    turns = {'0': '0', '1': '1', '8': '8', '6': '9', '9': '6'}
    lo = 0
    hi = len(num) - 1
    while lo <= hi:
        left = num[lo]
        if left not in turns:
            return False
        if turns[left] != num[hi]:
            return False
        lo += 1
        hi -= 1
    return True

The obvious version

Build the turned reading outright: walk the digits from the back, turn each one, and refuse the reading the moment a digit has no turned form. Then compare the string built against the original. Spends room on the turned reading rather than closing in from both ends.

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_is_strobogrammatic(num):
    turns = {'0': '0', '1': '1', '8': '8', '6': '9', '9': '6'}
    out = []
    for at in range(len(num) - 1, -1, -1):
        digit = num[at]
        if digit not in turns:
            return False
        out.append(turns[digit])
    return "".join(out) == num

How this problem was checked

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