3740. Minimum Distance Between Three Equal Elements I

/**
 * Problem: LeetCode 3740 - Minimum Distance Between Three Equal Elements I
 * Difficulty: Easy
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.*;

class Solution {
    public int minimumDistance(int[] nums) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        int minDistance = Integer.MAX_VALUE;

        for (int i = 0; i < nums.length; i++) {
            int val = nums[i];
            map.putIfAbsent(val, new ArrayList<>());
            List<Integer> indices = map.get(val);
            indices.add(i);

            int size = indices.size();
            if (size >= 3) {
                int first = indices.get(size - 3);
                int third = indices.get(size - 1);
                minDistance = Math.min(minDistance, 2 * (third - first));
            }
        }

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

"""
Problem: LeetCode 3740 - Minimum Distance Between Three Equal Elements I
Difficulty: Easy
Language: Python
Author: CodeByTushu
"""
from collections import defaultdict

class Solution:
    def minimumDistance(self, nums: list[int]) -> int:
        indices = defaultdict(list)
        min_dist = float('inf')

        for i, val in enumerate(nums):
            indices[val].append(i)
            if len(indices[val]) >= 3:
                min_dist = min(min_dist, 2 * (indices[val][-1] - indices[val][-3]))

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

/**
 * Problem: LeetCode 3740 - Minimum Distance Between Three Equal Elements I
 * Difficulty: Easy
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <climits>

using namespace std;

class Solution {
public:
    int minimumDistance(vector<int>& nums) {
        unordered_map<int, vector<int>> indices;
        int minDistance = INT_MAX;

        for (int i = 0; i < (int)nums.size(); ++i) {
            int val = nums[i];
            indices[val].push_back(i);

            int sz = indices[val].size();
            if (sz >= 3) {
                int first = indices[val][sz - 3];
                int third = indices[val][sz - 1];
                minDistance = min(minDistance, 2 * (third - first));
            }
        }

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

/**
 * Problem: LeetCode 3740 - Minimum Distance Between Three Equal Elements I
 * Difficulty: Easy
 * Language: JavaScript
 * Author: CodeByTushu
 */
/**
 * @param {number[]} nums
 * @return {number}
 */
var minimumDistance = function(nums) {
    const map = new Map();
    let minDistance = Infinity;

    for (let i = 0; i < nums.length; i++) {
        const val = nums[i];
        if (!map.has(val)) {
            map.set(val, []);
        }
        const list = map.get(val);
        list.push(i);

        const len = list.length;
        if (len >= 3) {
            const first = list[len - 3];
            const third = list[len - 1];
            minDistance = Math.min(minDistance, 2 * (third - first));
        }
    }

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