Question

我刚刚进行了在线编码访谈，其中一个问题是针对给定的整数数组，找出总和等于某个数字的对的数量（作为方法内的参数传递）。例如，数组为

int[] a = {3, 2, 1, 45, 27, 6, 78, 9, 0};
int k = 9; // given number

因此，将有2对（3,6）和（9,0），其总和等于9.值得一提的是，对形成的方式并不重要。装置（3,6）和（6,3）将被视为同一对。我提供了以下解决方案（用Java）并且很想知道我是否错过了任何边缘情况？

public static int numberOfPairs(int[] a, int k ){

    int len = a.length;

    if (len == 0){
      return -1;
    }

    Arrays.sort(a);
    int count  = 0, left = 0, right = len -1; 

    while( left < right ){

        if ( a[left] + a[right] == k  ){

            count++; 

            if (a[left] == a[left+1] && left < len-1 ){
              left++;
            }

            if ( a[right] == a[right-1] && right >1 ){
              right-- ; 
            }

            right--; // right-- or left++, otherwise, will get struck in the while loop 
        }

        else if ( a[left] + a[right] < k ){
          left++;
        }

        else {
          right--;
        }
    }

    return count; 
}

此外，任何人都可以提出任何替代解决方案吗？感谢。

Answer 1

请检查以下代码。

HashSet

时间复杂度为 O（n）。

希望这有帮助。

Answer 2

您的解决方案过于复杂，您可以更轻松地完成此练习：

public static int numberOfPairs(int[] a, int k ){

    int count=0;
    List<Integer> dedup = new ArrayList<>(new HashSet<>(Arrays.asList(a)));
    for (int x=0 ; x < dedup.size() ; x++ ){
        for (int y=x+1 ; y < dedup.size() ; y++ ){
            if (dedup.get(x)+dedup.get(y) == k)
                count++;
        }
    }

    return count;
}

这里的技巧是在第一个循环索引之后开始循环，不要将相同的值计数两次，而不是将它与你自己的索引进行比较。此外，您可以对阵列进行重复数据删除以避免重复对，因为它们并不重要。

您还可以对列表进行排序，然后在您的总和高于break时，k循环，但这是优化。

Answer 3

您可以使用HashMap<K,V>，其中K：a [i]和V：k-a [i] 如果数组中有重复项，则可能导致错误的答案。

对实例说：

int a[] = {4, 4, 4, 4, 4, 4, 4, 4, 4}

其中k = 8或：

int a[] = {1, 3, 3, 3, 3, 1, 2, 1, 2}

其中k = 4。

因此，为了避免这种情况，我们可以使用List<List<Integer>>，它可以检查每一对，并查看它们是否已经在列表中。

static int numberOfPairs(int[] a, int k)
{
    List<List<Integer>> res = new ArrayList<>();
    Map<Integer, Integer> map = new HashMap<>();
    for(int element:a)
    {
        List<Integer> list = new ArrayList<>();
        if(map.containsKey(element))
        {
            list.add(element);
            list.add(map.get(element));
            if(!res.contains(list))
                res.add(list);
        }
        else
            map.put(k - element, element);        
    }
    return res.size();
}

Answer 4

给出一个整数数组和一个目标值，确定差值等于目标值的数组元素对的数量。该函数具有以下参数：

k ：一个整数，目标差

arr ：整数数组

使用LINQ，这是一个不错的解决方案：

    public static int CountNumberOfPairsWithDiff(int k, int[] arr)
    {
        var numbers = arr.Select((value) => new { value });
        var pairs = from num1 in numbers
                    join num2 in numbers
                    on num1.value - k equals num2.value
                    select new[]
                {
                    num1.value, // first number in the pair
                    num2.value, // second number in the pair
                };
        foreach (var pair in pairs)
        {
            Console.WriteLine("Pair found: " + pair[0] + ", " + pair[1]);
        }

        return pairs.Count();
    }

Answer 5

此代码将提供等于给定总和的对以及等于总和的元素对的计数

 private void pairofArrayElementsEqualstoGivenSum(int sum,Integer[] arr){
        int count=0;
        List numList = Arrays.asList(arr);
        for (int i = 0; i < arr.length; i++) {
            int num = sum - arr[i];
            if (numList.contains(num)) {
                count++;
                System.out.println("" + arr[i] + " " + num + " = "+sum);
            }
        }
        System.out.println("Total count of pairs "+count);
    }

计算总和等于给定数字的数组对？

5 个答案: