3761. Minimum Absolute Distance Between Mirror Pairs

/**
 * Problem: LeetCode 3761 - Minimum Absolute Distance Between Mirror Pairs
 * Difficulty: Medium
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.HashMap;
import java.util.Map;

class Solution {
    private int reverse(int x) {
        long rev = 0;
        while (x > 0) {
            rev = rev * 10 + (x % 10);
            x /= 10;
        }
        return rev > 1_000_000_000L ? -1 : (int) rev;
    }

    public int minMirrorPairDistance(int[] nums) {
        Map<Integer, Integer> lastSeen = new HashMap<>();
        int minDistance = Integer.MAX_VALUE;

        for (int j = 0; j < nums.length; ++j) {
            int val = nums[j];
            
            // Check if nums[j] matches reverse(nums[i]) from an earlier index i
            if (lastSeen.containsKey(val)) {
                int dist = j - lastSeen.get(val);
                minDistance = Math.min(minDistance, dist);
                if (minDistance == 1) {
                    return 1; // Minimum possible distance between distinct indices
                }
            }

            // Record reverse(nums[j]) with its current index j
            int rev = reverse(val);
            if (rev != -1) {
                lastSeen.put(rev, j);
            }
        }

        return minDistance == Integer.MAX_VALUE ? -1 : minDistance;
    }
}

"""
Problem: LeetCode 3761 - Minimum Absolute Distance Between Mirror Pairs
Difficulty: Medium
Language: Python
Author: CodeByTushu
"""
from typing import List

class Solution:
    def minMirrorPairDistance(self, nums: List[int]) -> int:
        def reverse(x: int) -> int:
            rev = 0
            while x > 0:
                rev = rev * 10 + (x % 10)
                x //= 10
            return rev

        last_seen = {}
        min_dist = float('inf')

        for j, val in enumerate(nums):
            # Check if nums[j] matches reverse(nums[i]) from an earlier index i
            if val in last_seen:
                dist = j - last_seen[val]
                if dist < min_dist:
                    min_dist = dist
                    if min_dist == 1:
                        return 1

            # Record reverse(nums[j]) with its current index j
            rev = reverse(val)
            if rev <= 10**9:
                last_seen[rev] = j

        return -1 if min_dist == float('inf') else min_dist

/**
 * Problem: LeetCode 3761 - Minimum Absolute Distance Between Mirror Pairs
 * Difficulty: Medium
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <climits>

using namespace std;

class Solution {
private:
    int reverseNum(int x) {
        long long rev = 0;
        while (x > 0) {
            rev = rev * 10 + (x % 10);
            x /= 10;
        }
        return rev > 1000000000LL ? -1 : static_cast<int>(rev);
    }

public:
    int minMirrorPairDistance(vector<int>& nums) {
        unordered_map<int, int> lastSeen;
        int minDistance = INT_MAX;

        for (int j = 0; j < static_cast<int>(nums.size()); ++j) {
            const int val = nums[j];

            // Check if nums[j] matches reverse(nums[i]) from an earlier index i
            auto it = lastSeen.find(val);
            if (it != lastSeen.end()) {
                const int dist = j - it->second;
                minDistance = min(minDistance, dist);
                if (minDistance == 1) {
                    return 1;
                }
            }

            // Record reverse(nums[j]) with its current index j
            const int rev = reverseNum(val);
            if (rev != -1) {
                lastSeen[rev] = j;
            }
        }

        return minDistance == INT_MAX ? -1 : minDistance;
    }
};

/**
 * Problem: LeetCode 3761 - Minimum Absolute Distance Between Mirror Pairs
 * Difficulty: Medium
 * Language: JavaScript
 * Author: CodeByTushu
 */
/**
 * @param {number[]} nums
 * @return {number}
 */
var minMirrorPairDistance = function(nums) {
    const reverseNum = (x) => {
        let rev = 0;
        while (x > 0) {
            rev = rev * 10 + (x % 10);
            x = Math.floor(x / 10);
        }
        return rev > 1000000000 ? -1 : rev;
    };

    const lastSeen = new Map();
    let minDistance = Infinity;

    for (let j = 0; j < nums.length; ++j) {
        const val = nums[j];

        // Check if nums[j] matches reverse(nums[i]) from an earlier index i
        if (lastSeen.has(val)) {
            const dist = j - lastSeen.get(val);
            if (dist < minDistance) {
                minDistance = dist;
                if (minDistance === 1) return 1;
            }
        }

        // Record reverse(nums[j]) with its current index j
        const rev = reverseNum(val);
        if (rev !== -1) {
            lastSeen.set(rev, j);
        }
    }

    return minDistance === Infinity ? -1 : minDistance;
};