1class Solution {
2    public int minAbsoluteDifference(int[] nums) {
3        int length = nums.length;
4
5        // Initialize the answer to an impossible-large value (sentinel).
6        // Any valid gap will be at most length - 1, so length + 1 means "not found".
7        int minGap = length + 1;
8
9        // lastIndex[v] stores the most recent position where value v appeared.
10        // Only indices 1 and 2 are used (index 0 is unused padding).
11        // They start far in the "past" so that early reads produce large gaps
12        // that never beat a real answer.
13        int[] lastIndex = new int[3];
14        Arrays.fill(lastIndex, -(length + 1));
15
16        for (int i = 0; i < length; i++) {
17            int value = nums[i];
18
19            // Skip zeros: they are neither of the two complementary values.
20            if (value != 0) {
21                // 3 - value maps 1 <-> 2, giving the complementary value's index.
22                // Distance from the current index to the last complementary value.
23                int complementIndex = 3 - value;
24                minGap = Math.min(minGap, i - lastIndex[complementIndex]);
25
26                // Record the current position for this value.
27                lastIndex[value] = i;
28            }
29        }
30
31        // If minGap was never updated to a real value, no valid pair exists.
32        return minGap > length ? -1 : minGap;
33    }
34}
35```
36
37**A note on correctness / perspectives:**
38
391. **What it computes:** the minimum index distance between an element equal to `1` and an element equal to `2`. The variable naming (`minAbsoluteDifference`) suggests it may be a partial/specialized solution rather than a general "minimum absolute difference" problem — the values are restricted to `{0, 1, 2}`.
40
412. **Index safety:** because the only non-zero writes are for `value ∈ {1, 2}`, `lastIndex[value]` and `lastIndex[3 - value]` stay within bounds `[1, 2]`. If `nums` could contain other non-zero values, this would throw an `ArrayIndexOutOfBoundsException`, so the precondition `nums[i] ∈ {0, 1, 2}` is implicit.
42
433. **Alternative styling:** instead of the size-3 array with an unused slot, you could use two explicit variables `lastOne` and `lastTwo` for clarity, trading the compact `3 - value` trick for more readable code:
44
45```java
46int lastOne = -(length + 1);
47int lastTwo = -(length + 1);
48// ...
49if (value == 1) { minGap = Math.min(minGap, i - lastTwo); lastOne = i; }
50else if (value == 2) { minGap = Math.min(minGap, i - lastOne); lastTwo = i; }
51

1class Solution {
2public:
3    int minAbsoluteDifference(vector<int>& nums) {
4        int n = nums.size();
5
6        // Initialize the answer with a value larger than any possible distance.
7        int minDistance = n + 1;
8
9        // last[v] stores the most recent index at which value v appeared.
10        // Initialized to a large negative value so that the first comparison
11        // does not produce a valid (small) distance by accident.
12        vector<int> last(3, -(n + 1));
13
14        for (int i = 0; i < n; ++i) {
15            int value = nums[i];
16
17            // Only non-zero values are meaningful here (values are 1 or 2).
18            if (value != 0) {
19                // The complementary value: if value is 1 -> 2, if value is 2 -> 1.
20                int complement = 3 - value;
21
22                // Update the answer with the distance between the current index
23                // and the last index where the complementary value appeared.
24                minDistance = min(minDistance, i - last[complement]);
25
26                // Record the current index as the latest occurrence of this value.
27                last[value] = i;
28            }
29        }
30
31        // If no valid pair was found, minDistance stays greater than n -> return -1.
32        return minDistance > n ? -1 : minDistance;
33    }
34};
35

1/**
2 * Finds the minimum absolute difference of indices between two elements
3 * whose values sum to 3 (i.e., a pair of 1 and 2).
4 *
5 * The array is expected to contain values in {0, 1, 2}, where:
6 *   - 1 and 2 are complementary (1 + 2 = 3)
7 *   - 0 is treated as a "blank" / ignored value
8 *
9 * @param nums - The input array of numbers.
10 * @returns The minimum index distance between a complementary pair, or -1 if none exists.
11 */
12function minAbsoluteDifference(nums: number[]): number {
13    const n: number = nums.length;
14
15    // Initialize the answer to an impossible large value (sentinel).
16    let ans: number = n + 1;
17
18    // lastIndex[v] stores the most recent index where value v appeared.
19    // Initialized to a large negative sentinel so early comparisons
20    // never produce a valid (small) distance by accident.
21    const lastIndex: number[] = Array(3).fill(-ans);
22
23    for (let i = 0; i < n; ++i) {
24        const x: number = nums[i];
25
26        // Skip the "blank" value 0; only process 1 and 2.
27        if (x) {
28            // The complement of x is (3 - x):
29            //   if x === 1, complement is 2
30            //   if x === 2, complement is 1
31            // Distance from the last occurrence of the complement.
32            ans = Math.min(ans, i - lastIndex[3 - x]);
33
34            // Record the current index as the latest position of value x.
35            lastIndex[x] = i;
36        }
37    }
38
39    // If ans was never updated to a valid distance, return -1.
40    return ans > n ? -1 : ans;
41}
42