0056MediumMath

Legacy Register Flip

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.

An old flow meter transmits its counter as reading, a signed whole number. The meter's firmware was wired back to front, so the decimal digits arrive in the opposite order to the one intended, and the decoder has to undo that: keep the sign as it is and read the digits the other way round. Any zeros that end up in front simply vanish, since the decoded counter is a number rather than a run of characters, so a reading of 4100 decodes to 14.

The decoder is a small board with one signed 32-bit register, so it can only ever hold a value from -2^31 through 2^31 - 1. Nothing wider is available: no 64-bit slot, no unbounded arithmetic, and no scratch buffer of characters. If the decoded counter would fall outside what the register holds, the decoder gives up and reports 0. Return the decoded counter.

Examples

Example 1

Input: reading = 8104
Output: 4018

Reading the digits 8, 1, 0, 4 the other way round gives 4, 0, 1, 8.

Example 2

Input: reading = -3570
Output: -753

The digits flip to 0, 7, 5, 3 and the leading zero drops away, while the sign rides along unchanged.

Example 3

Input: reading = 1999999999
Output: 0

The flipped digits spell a counter above 2^31 - 1, which the register cannot hold, so the decoder reports failure.

Constraints

-2^31 <= reading <= 2^31 - 1
No value outside the signed 32-bit range may be held at any point, so overflow has to be ruled out before it happens

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 flip_register(reading: int) -> int:

Java

public int flipRegister(int reading)

The intended approach

Time O(d) for the d digits of the readingSpace O(1)

Peel the lowest digit off the reading with a remainder, shave it off with a division, and push it onto the accumulating answer by multiplying by ten and adding. The only trap is the push itself, so test it against the register's limits before performing it: an accumulator already past 214748364 always overflows, and one sitting exactly on 214748364 overflows only when the incoming digit passes the last digit of the limit. Negative readings run on the mirrored bounds with digits carried as negative values, which keeps the sign correct without ever negating the reading, something the most negative input would not survive.

Pythonentry point: flip_register

def flip_register(reading):
    result = 0
    value = reading
    if value >= 0:
        while value != 0:
            digit = value % 10
            value //= 10
            if result > 214748364 or (result == 214748364 and digit > 7):
                return 0
            result = result * 10 + digit
    else:
        while value != 0:
            digit = value % -10
            value = (value - digit) // 10
            if result < -214748364 or (result == -214748364 and digit < -8):
                return 0
            result = result * 10 + digit
    return result

The obvious version

Render the reading as characters, turn the digit run around, parse it back with unbounded arithmetic and only then check whether the outcome fits the register. Ignores the width restriction the statement imposes, but it is easy to trust.

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_flip_register(reading):
    text = str(reading)
    if text.startswith("-"):
        flipped = -int(text[1:][::-1])
    else:
        flipped = int(text[::-1])
    if flipped < -2147483648 or flipped > 2147483647:
        return 0
    return flipped

How this problem was checked

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