查找第二次出现索引最低的第一个重复元素

Question

我正在尝试解决 CodeFights 上名为 firstDuplicate 的问题 -

给定一个数组 a 只包含从 1 到 a.length，找到第二个重复的数字 出现具有最小索引。换句话说，如果有更多 超过 1 个重复的数字，返回第二个的数字 出现的索引小于另一个的第二次出现 号码可以。如果没有这样的元素，则返回 -1。

例子

对于a = [2, 3, 3, 1, 5, 2]，输出应该是firstDuplicate(a) = 3.

有 2 个重复项：数字 2 和 3。第二次出现 3 具有比第二次出现的 2 小的索引，因此 答案是 3。

对于 a = [2, 4, 3, 5, 1]，输出应该是 firstDuplicate(a) = -1。

我的解决方案 -

public class FirstDuplicate {
    private static HashMap<Integer, Integer> counts = new HashMap<>();

    private static void findSecondIndexFrom(int[] num, int n, int i) {
    // given an array, a starting index and a number, find second occurrence of that number beginning from next index
        for(int x = i; x < num.length; x++) {
            if(num[x] == n) {
              // second occurrence found - place in map and terminate
                counts.put(n, x);
                return;
            }
        }


    }

    private static int firstDuplicate(int[] a) {
        // for each element in loop, if it's not already in hashmap
        // find it's second occurrence in array and place number and index in map

        for(int i = 0; i < a.length; i++) {
            if(!counts.containsKey(a[i])) {
                findSecondIndexFrom(a, a[i], i+1);
            }
        }

        System.out.println(counts);
        // if map is empty - no duplicate elements, return -1
        if(counts.size() == 0) {
            return -1;
        }
        // else - get array of values from map, sort it, find lowest value and return corresponding key

        ArrayList<Integer> values = new ArrayList<>(counts.values());
        Collections.sort(values);
        int lowest = values.get(0);
        //System.out.println(lowest);
        for(Map.Entry<Integer, Integer> entries: counts.entrySet()) {
            if(entries.getValue() == lowest) {
                return entries.getKey();
            }
        }
     return -1;
    }

    public static void main(String[] args) {
         // int[] a = new int[]{2, 3, 3, 1, 5, 2};
         //int[] a = new int[]{2, 4, 3, 5, 1};
         //int[] a = new int[]{8, 4, 6, 2, 6, 4, 7, 9, 5, 8};
        //int[] a = new int[]{1, 1, 2, 2, 1};

        int[] a = new int[]{10, 6, 8, 4, 9, 1, 7, 2, 5, 3};
        System.out.println(firstDuplicate(a));
    }


}

该解决方案仅在 CodeFights 上的 11 个测试用例中的大约 4 个通过。但是，我在 IDE 中手动执行了每个测试用例，每个测试用例都产生了正确的结果。

我不明白为什么这在 CodeFights 中不起作用。和使用静态HashMap有关系吗？

Answer 1

已编辑：由于添加和检查 Set 中是否存在元素可以一步完成，因此代码可以简化为：

public static int findDuplicateWithLowestIndex(int... a){
Set<Integer> set = new HashSet<>();
   for(int num : a){
     if(!set.add(num)){
        return num;
       }
    }
return -1; 
}

你完全正确，帕特里克。

Answer 2

使用这个解决方案：这里的 duplicateIndex 应该是非常大的数字。

    package sample;

    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;

    public class Duplicate {

public static Integer secondIndex(Integer[] arr) {
    List<Integer> arrlist = new ArrayList<>(Arrays.asList(arr));
    int duplicateIndex = 999;
    int ele = 0;

    for (int i = 0; i < arrlist.size(); i++) {
        int secondIndex = getSecondIndex(arrlist, arrlist.get(i));

        if (secondIndex >= 0 && duplicateIndex > secondIndex) {
            duplicateIndex = secondIndex;
            ele = arrlist.get(i);
        }
    }

    return duplicateIndex == 999 ? -1 : ele;
}

public static int getSecondIndex(List<Integer> arr, int ele) {
    List<Integer> var0 = new ArrayList<>(arr);
    var0.set(var0.indexOf(ele), -1);
    return var0.indexOf(ele);
}

public static void main(String[] str) {
    // Integer[] arr = new Integer[] { 2, 3, 3, 1, 5, 2 };
    // Integer[] arr = new Integer[] { 2, 4, 3, 5, 1 };
    // Integer[] arr = new Integer[] { 8, 4, 6, 2, 6, 4, 7, 9, 5, 8 };
    // Integer[] arr = new Integer[]{1, 1, 2, 2, 1};
    Integer[] arr = new Integer[] { 10, 6, 8, 4, 9, 1, 7, 2, 5, 3 };
    System.out.println(secondIndex(arr));
}
}