3783. Mirror Distance of an Integer

Problem Statement

You are given an integer n.

Define its mirror distance as: abs(n - reverse(n)) where reverse(n) is the integer formed by reversing the digits of n.

Return an integer denoting the mirror distance of n.

abs(x) denotes the absolute value of x.

Key Insight

The solution requires understanding these crucial observations:

1. We need to reverse the digits of the integer n
2. The reversal should ignore leading zeros in the result (e.g., reverse(10) = 1, not 01)
3. We need to compute the absolute difference between the original and reversed numbers
4. For single-digit numbers or palindromic numbers, the mirror distance will be 0
5. The mathematical approach using modulo/division is efficient and avoids string conversion overhead

Alternative approach: Convert to string, reverse the string, convert back to integer.

Approach 1: Mathematical Reversal (Optimal)

Reverse the integer mathematically using modulo and division operations. This approach is efficient and avoids string conversion overhead.

Algorithm Steps

1. Initialize reversed = 0 and create a copy temp = n
2. While temp > 0:
   • Extract last digit: digit = temp % 10
   • Append to reversed: reversed = reversed * 10 + digit
   • Remove last digit: temp = temp / 10
3. Compute abs(n - reversed)
4. Return the result

How It Works

This approach builds the reversed number digit by digit. For example, for n = 123:

• Iteration 1: digit = 3, reversed = 3, temp = 12
• Iteration 2: digit = 2, reversed = 32, temp = 1
• Iteration 3: digit = 1, reversed = 321, temp = 0

Complexity Analysis

Where d is the number of digits in n. We process each digit once with constant extra space.

class Solution {
public:
    int mirrorDistance(int n) {
        int temp = 0;
        int num = n;
        
        while (num) {
            int digit = num % 10;
            temp = temp * 10 + digit;
            num /= 10;
        }
        
        return abs(n - temp);
    }
};

class Solution {
    public int mirrorDistance(int n) {
        int reversed = 0;
        int temp = n;
        
        while (temp != 0) {
            int digit = temp % 10;
            reversed = reversed * 10 + digit;
            temp /= 10;
        }
        
        return Math.abs(n - reversed);
    }
}

class Solution:
    def mirrorDistance(self, n: int) -> int:
        reversed_num = 0
        temp = n
        
        while temp > 0:
            digit = temp % 10
            reversed_num = reversed_num * 10 + digit
            temp //= 10
        
        return abs(n - reversed_num)

Approach 2: String Reversal

Convert the integer to string, reverse the string, convert back to integer, and compute the absolute difference.

Algorithm Steps

1. Convert n to string: str_n = to_string(n)
2. Create reversed string: reversed_str = reverse(str_n)
3. Convert reversed string to integer: reversed_n = stoi(reversed_str)
4. Compute abs(n - reversed_n)
5. Return the result

How It Works

This approach leverages built-in string reversal functions. For n = 123:

• String: "123"
• Reversed: "321"
• Convert to int: 321
• Result: abs(123 - 321) = 198

Complexity Analysis

Where d is the number of digits. We need O(d) space for the string representation.

class Solution {
public:
    int mirrorDistance(int n) {
        string str_n = to_string(n);
        string reversed_str = str_n;
        reverse(reversed_str.begin(), reversed_str.end());
        
        int reversed_n = stoi(reversed_str);
        return abs(n - reversed_n);
    }
};

class Solution {
    public int mirrorDistance(int n) {
        String str_n = Integer.toString(n);
        StringBuilder sb = new StringBuilder(str_n);
        String reversed_str = sb.reverse().toString();
        
        int reversed_n = Integer.parseInt(reversed_str);
        return Math.abs(n - reversed_n);
    }
}

class Solution:
    def mirrorDistance(self, n: int) -> int:
        str_n = str(n)
        reversed_str = str_n[::-1]
        reversed_n = int(reversed_str)
        return abs(n - reversed_n)

Approach 3: Recursive Reversal

Reverse the integer recursively by processing one digit at a time. This demonstrates recursive thinking for number manipulation problems.

Algorithm Steps

1. Define helper function reverseRecursive(num, rev)
2. Base case: if num == 0, return rev
3. Recursive case: extract last digit, update reversed number, recurse with remaining digits
4. Main function: call helper and compute absolute difference

How It Works

Recursively builds the reversed number. For n = 123:

• reverseRecursive(123, 0) → reverseRecursive(12, 3)
• reverseRecursive(12, 3) → reverseRecursive(1, 32)
• reverseRecursive(1, 32) → reverseRecursive(0, 321)
• Return 321

Complexity Analysis

Where d is the number of digits. The recursion depth is d, so O(d) space for the call stack.

class Solution {
private:
    int reverseRecursive(int num, int rev) {
        if (num == 0) {
            return rev;
        }
        int digit = num % 10;
        return reverseRecursive(num / 10, rev * 10 + digit);
    }
    
public:
    int mirrorDistance(int n) {
        int reversed = reverseRecursive(n, 0);
        return abs(n - reversed);
    }
};

class Solution {
    private int reverseRecursive(int num, int rev) {
        if (num == 0) {
            return rev;
        }
        int digit = num % 10;
        return reverseRecursive(num / 10, rev * 10 + digit);
    }
    
    public int mirrorDistance(int n) {
        int reversed = reverseRecursive(n, 0);
        return Math.abs(n - reversed);
    }
}

class Solution:
    def reverseRecursive(self, num: int, rev: int) -> int:
        if num == 0:
            return rev
        digit = num % 10
        return self.reverseRecursive(num // 10, rev * 10 + digit)
    
    def mirrorDistance(self, n: int) -> int:
        reversed_num = self.reverseRecursive(n, 0)
        return abs(n - reversed_num)

Approach 4: Two-Pointer String Reversal

Use two pointers to reverse the string representation of the number, then convert back to integer.

Algorithm Steps

1. Convert n to string
2. Initialize two pointers: left = 0, right = length - 1
3. While left < right, swap characters at left and right
4. Increment left, decrement right
5. Convert reversed string to integer
6. Compute absolute difference

How It Works

This is similar to Approach 2 but manually implements string reversal using two pointers instead of built-in functions.

Complexity Analysis

Same as string reversal approach but demonstrates manual string manipulation.

class Solution {
public:
    int mirrorDistance(int n) {
        string str_n = to_string(n);
        int left = 0, right = str_n.length() - 1;
        
        while (left < right) {
            swap(str_n[left], str_n[right]);
            left++;
            right--;
        }
        
        int reversed_n = stoi(str_n);
        return abs(n - reversed_n);
    }
};

class Solution {
    public int mirrorDistance(int n) {
        char[] chars = Integer.toString(n).toCharArray();
        int left = 0, right = chars.length - 1;
        
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        
        int reversed_n = Integer.parseInt(new String(chars));
        return Math.abs(n - reversed_n);
    }
}

class Solution:
    def mirrorDistance(self, n: int) -> int:
        chars = list(str(n))
        left, right = 0, len(chars) - 1
        
        while left < right:
            chars[left], chars[right] = chars[right], chars[left]
            left += 1
            right -= 1
        
        reversed_n = int(''.join(chars))
        return abs(n - reversed_n)

Visual Example Walkthrough

Let's trace through Approach 1 (Mathematical Reversal) with n = 123:

Original Number: 123

Reversed Number: 321

Comparison of Approaches

Edge Cases and Testing

1. Single Digit Numbers

Input: n = 7 → Output: 0
Reversed: 7, Difference: |7 - 7| = 0
All single-digit numbers have mirror distance 0

2. Numbers Ending with Zero

Input: n = 10 → Output: 9
Reversed: 01 which is 1, Difference: |10 - 1| = 9
Important: Leading zeros are dropped when converting to integer

3. Palindromic Numbers

Input: n = 121 → Output: 0
Reversed: 121, Difference: |121 - 121| = 0
All palindromes have mirror distance 0

4. Maximum Input

Input: n = 1000000000 (10⁹) → Output: 999999999
Reversed: 1, Difference: |1000000000 - 1| = 999999999
Largest possible mirror distance

5. Minimum Input

Input: n = 1 → Output: 0
Reversed: 1, Difference: |1 - 1| = 0

6. Symmetric Numbers

Input: n = 12321 → Output: 0
Reversed: 12321, Difference: |12321 - 12321| = 0
Another palindrome example

7. Numbers with All Same Digits

Input: n = 999 → Output: 0
Reversed: 999, Difference: |999 - 999| = 0

8. Large Difference Case

Input: n = 100 → Output: 99
Reversed: 1, Difference: |100 - 1| = 99
Numbers with many trailing zeros have large mirror distance

FAQs