HackerRank 上的 Pairs 算法

Question

让我快速解释一下问题

最初来自这里：https://www.hackerrank.com/challenges/pairs

示例输入为：

5 2  
1 5 3 4 2

引用上述输入

第一行：

N = 5, K = 2 

其中 N 是集合中的整数个数，K 是我们要寻找的差值

第二行（作为一个数组）：

[1, 5, 3, 4, 2];

数组中有多少对相差K？

示例答案： "集合中有3对相差2的整数。"

这是我正在为此做的事情，但我错过了一些东西：

function findDifference(k, nArr) {

    nArr.sort((a, b) => a - b);

var pairsWithDifferenceOfK = 0;

for (var i = 0; i < nArr.length; i++) {
    if (Math.abs((nArr[i] - ((nArr.length > (i + k)) ? nArr[(i + k)] : nArr[i]))) === k) {
       pairsWithDifferenceOfK++;
   };
}
   console.log(pairsWithDifferenceOfK);
}
var K = 2;
Arr = [1, 5, 3, 4, 2];
findDifference(K, Arr);

输出：

3

当给定这些输入时，这会失败（我很好奇为什么在某些输入而不是其他输入上失败）：

10 1
363374326 364147530 61825163 1073065718 1281246024 1399469912 42804763 491595254 879792181 1069262793

Answer 1

解决此问题的一种方法是递归。在函数的每次迭代中，您可以获取第一个元素，然后将其与其余元素进行比较。因此，例如，您从

开始

var rest = arr.splice(1);

其中rest 是[5, 3, 4, 2]，您将每个元素与1 进行比较，然后将rest 传递给您将[3, 4, 2] 与5 进行比较的函数等...然后检查每个元素是否存在差异k 如果是你增加结果。当arr参数变为空数组函数将退出或返回1。

var K = 2;
var array = [1, 5, 3, 4, 2];

function findDifference(k, arr) {
  var r = 0;

  function inner(k, arr) {
    if (!arr.length) return 1;
    var rest = arr.splice(1);

    rest.forEach(function(e) {
      if (Math.abs(arr[0] - e) == k) r++;
    })

    inner(k, rest);
  }
  inner(k, arr);
  return r;
}

console.log(findDifference(K, array));

Answer 2

通过Set 在 JavaScript 中实现的近线性解决方案如下：

function pairs(k, arr) {
  const points = new Set(arr);
  let pairs = 0;
  for (let i = 0; i < arr.length; i++) {
    if (points.has(arr[i] - k)) {
      pairs++;
    }
  }
  return pairs;
}

console.log(pairs(2, [1, 5, 3, 4, 2]));

假设Set会在O(1)时间返回元素的存在

Answer 3

我建议你用对的组合填充一个数组，并删除那些与 K 不匹配的数组。然后你只需要返回最终数组的长度：

var findDifference = (array, K) => {
  var pairs = [];
  array.forEach((x, i, arr) => arr.slice(i+1).forEach(y => pairs.push([x, y])));
  return pairs.filter(x => Math.abs(x[0]-x[1]) === 2).length;
}

console.log(findDifference([1, 5, 3, 4, 2], 2));

Answer 4

你可以这样做；

function countTargetDiff(ar,td){
  return ar.reduce((p,c,i,a) => p += a.slice(i+1).filter(f => Math.abs(c-f) === td).length,0);
}
arr = [1, 5, 3, 4, 2],
  k = 2,
res = countTargetDiff(arr,k);

console.log(res);

Answer 5

您可以使用for 循环、Array.prototype.filter()、Array.prototype.slice() 将数组的每个元素与数组的其余部分进行比较。

var array = [1, 5, 3, 4, 2];
var n = 0;

for (var i = 0, j = 2; i < array.length; i++) {
  if (i + 1 < array.length) {
    var curr = array[i];
    var not = array.slice(i + 1).filter(function(el) {
      return el !== curr;
    });
    var diff = not.filter(function(el) {
      return el - curr === j || curr - el === j
    });
    if (diff.length) {
      n += 1
    }
  }
}

console.log(n)

Answer 6

这个挑战的问题是测试用例 10 到 14 使用了大量的数字，所以你必须找到一种有效的方法来避免超时问题。

解决这个问题的另一种方法是每次比较排序数组中的两个数字，根据它们的差异。

基本上，如果 numA 和 numB 之间的差小于 K，您就知道必须通过 numB 向右移动来找到更大的数字。如果您的差异大于 K，您知道您必须通过寻找更大的 numA 来缩小差距。

const n = 5, k = 2, numbers = [1, 5, 3, 4 ,2]
numbers.sort((a, b) => a - b); //increasing order

let index1 = 0, index2 = 1, pairs = 0;
while (index2 < n) {
  let difference = numbers[index2] - numbers[index1];
  if (difference === k) (pairs++, index2++);
  if (difference < k) index2++;
  if (difference > k) index1++;
}
console.log(pairs === 3);

这样可以大大减少操作次数，从而降低最差的复杂性。你应该通过这个挑战的所有 16 个测试用例。

Answer 7

    function pairs(k, arr) {
    let numberOfPairs = 0;
    let sorted = arr.sort((numA, numB) => numA - numB);
  
    for(let i=0; i < sorted.length; i++) {
        for(let j= i + 1; j < sorted.length; j++) {
          let difference = sorted[j] - sorted[i]
            if(difference === k) {
               numberOfPairs++;
               break
            } if(difference > k) {
              break
            }
        } 
    }
   return numberOfPairs;