Minimum Absolute Distance Between Mirror Pairs - Solution & Explanation

Problem Overview: Given an array of integers, you need the smallest absolute distance between indices i and j such that the two values form a mirror pair. A mirror pair means one value is the mathematical mirror of the other (for example x and -x). The goal is to scan the array and return the minimum |i - j| among all valid pairs.

Approach 1: Brute Force Pair Check (O(n²) time, O(1) space)

The straightforward method checks every pair of indices. For each i, iterate through all j > i and test whether nums[i] and nums[j] are mirrors. When a mirror condition is satisfied, compute the absolute index difference and track the minimum. This approach is easy to implement but inefficient for large arrays because it performs roughly n × n comparisons. It mainly serves as a baseline and demonstrates the problem constraints clearly.

Approach 2: Hash Table Lookup (O(n) time, O(n) space)

The optimal solution uses a hash table to remember previously seen numbers and their indices while scanning the array once. When processing an element x at index i, compute its mirror value -x. A constant-time hash lookup tells you whether that mirror appeared earlier. If it exists, compute the index distance |i - prevIndex| and update the minimum distance.

This approach works because each element’s mirror relationship can be checked instantly with a hash map instead of searching the entire array. You simply iterate through the array, perform a hash lookup, and update the stored index for the current number. The algorithm runs in linear time with additional storage for the map. The mirror relationship relies on a simple math transformation (-x), which keeps the logic straightforward.

Recommended for interviews: Start by mentioning the brute force pair comparison to show you understand the definition of mirror pairs and the distance requirement. Then move quickly to the hash table approach. Interviewers expect the O(n) single-pass solution because it demonstrates familiarity with hash-based lookups and common array optimization patterns.