0927EasyMath

Gap to the Mirrored Number

Tracked in this browser only

Trains the technique from

LeetCode 3783Mirror Distance of an Integer

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.

Reading the digits of n in the opposite order gives another whole number, dropping any leading zeros that appear.

Return how far apart the two numbers are.

Examples

Example 1

Input: n = 4213
Output: 1089

Reading the digits the other way gives 3124, and 4213 less 3124 is 1089.

Example 2

Input: n = 200
Output: 198

The digits read backwards give 002, which is the number 2, so the gap is 198.

Example 3

Input: n = 1221
Output: 0

The number reads the same either way, so the gap is nothing.

Constraints

1 <= n <= 10^9

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 mirror_distance(n: int) -> int:

Java

public int mirrorDistance(int n)

The intended approach

Time O(d) for the d digits of n.Space O(1).

Build the mirrored number arithmetically: repeatedly take the last digit of what is left, append it to a running total by multiplying that total by ten and adding the digit, then drop the digit. Leading zeros need no special handling because a zero appended to a running total that is still nothing simply leaves it nothing. The answer is then the difference of the two numbers, taken the way round that keeps it positive.

Pythonentry point: mirror_distance

def mirror_distance(n):
    mirrored = 0
    left = n
    while left > 0:
        mirrored = mirrored * 10 + left % 10
        left //= 10
    gap = n - mirrored
    return gap if gap >= 0 else -gap

The obvious version

Write the number out as text, reverse the text, read it back as a number, and subtract. Goes through strings rather than arithmetic.

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_mirror_distance(n):
    text = str(n)
    flipped = text[::-1]
    other = int(flipped)
    if n > other:
        return n - other
    return other - n

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