1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class Solution {
public:
    int minimumDistance(vector<int>& nums) {
        std::unordered_map<int, std::vector<int>> f;
        for (int i = 0; i < nums.size(); ++ i)
            f[nums[i]].push_back(i); // record all the indices of each element

        int res = INT_MAX;
        for (auto [_, p] : f) // iterate each index array
            for (int i = 2; i < p.size(); ++ i)
                res = std::min(res, (p[i] - p[i - 2]) * 2); // calculate minimum distance = 2 * (k - i)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Solution:
    def minimumDistance(self, nums: List[int]) -> int:
        f = {}
        for i, x in enumerate(nums):
            if x not in f:
                f[x] = []
            f[x].append(i)

        res = float('inf')
        for p in f.values():
            for i in range(2, len(p)):
                res = min(res, (p[i] - p[i - 2]) * 2)

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

func minimumDistance(nums []int) int {
    f := make(map[int][]int)
    for i := 0; i < len(nums); i ++ {
        f[nums[i]] = append(f[nums[i]], i)
    }

    INF := 0x3f3f3f3f
    res := INF
    for _, p := range f {
        for i := 2; i < len(p); i ++ {
            if (p[i] - p[i - 2]) * 2 < res {
                res = (p[i] - p[i - 2]) * 2
            }
        }
    }

    if res == INF {
        return -1
    }

    return res
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

/**
 * @param {number[]} nums
 * @return {number}
 */
var minimumDistance = function (nums) {
  let f = new Map();
  for (let i = 0; i < nums.length; i++) {
    if (!f.has(nums[i])) f.set(nums[i], []);
    f.get(nums[i]).push(i);
  }

  let res = Infinity;
  for (let p of f.values()) {
    for (let i = 2; i < p.length; i++) {
      res = Math.min(res, (p[i] - p[i - 2]) * 2);
    }
  }

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