也许有一种比这个 O（2n） 解更快/更好的方法来计算这个问题，但它是：

var ar1 = [10, 20, 20, 10, 10, 30, 50, 10, 20] // return 3 (2 pairs of 10 and 1 pair of 20)
var ar2 = [1, 1, 3, 1, 2, 1, 3, 3, 3, 3] // return 4 (2 pairs of 1 and 2 pairs of 3)

function countPairs(ar) {
  var obj = {};

  ar.forEach(item => {
    obj[item] = obj[item] ? obj[item] + 1 : 1;
  });
  
  return Object.values(obj).reduce((acc, curr) => {
    acc += Math.floor(curr / 2)
    return acc;
  }, 0);
}

console.log(countPairs(ar1))
console.log(countPairs(ar2))

这首先计算每个数字的出现次数，并将其存储在Object中。完成后，我们对这些值进行化简，并返回与2相除的商（以获得总数）。

• 注意：* 我从函数中删除了第一个参数，因为数组长度不需要作为参数。它可以从你直接传递的数组中获得。

时间复杂度为O（n）维护一个对象，该对象跟踪一个数字之前是否被找到过，如果它之前被找到过，那么它组成一个对，所以我们增加对计数。如果不是，我们将该数字输入对象1

function countPairs(arr) {
    let pairs = 0;
    const obj = {};
    arr.forEach(i => {
        if (obj[i]) {
            pairs += 1;
            obj[i] = 0;
        } else {
            obj[i] = 1;
        }
    });
    return pairs;
}

我能找到的最简单的解决方案：
创建空字典var t = {};并使用它来计数数组arr.forEach (i => t[i] = (t[i] || 0) + 1);中的每个项目。之后，取所有键Object.values(t)，并将.reduce((acc, p) => acc + ..., 0)相加，每个项的计数除以2 p/2，当然，Int语义为Math.floor(...)。

function countPairs(arr) {
  var t = {}; 
  arr.forEach (i => t[i] = (t[i] || 0) + 1);
  return Object.values(t).reduce((acc, p) => acc + Math.floor(p/2), 0);
}

console.dir(countPairs([1,2,2,2,2,3]));
console.dir(countPairs([1,2,2,2,2,2,3]));
console.dir(countPairs([1,2,2,2,2,2,2,3]));
console.dir(countPairs([10, 20, 20, 10, 10, 30, 50, 10, 20]));
console.dir(countPairs([1, 1, 3, 1, 2, 1, 3, 3, 3, 3]));

实现中的第一个参数不是必需的。如果答案有帮助，请投票

使用Reduce方法的简洁方法

const countPairs = arr => (pairs = [], arr.reduce((p, c) => (p[c] ? (pairs.push([p[c], c]), delete p[c]) : p[c] = c, p), {}), pairs.length)
console.log(countPairs([10, 20, 20, 10, 10, 30, 50, 10, 20]));

所以，我想要一个更简单的解决方案来解决这个问题，因为我刚刚开始学习编码，我正在自学。我发现这个解决方案非常适合你想要的。我没有创建这个解决方案，我在互联网上找到了它（https://www.geeksforgeeks.org/count-equal-element-pairs-in-the-given-array/），我只是将其翻译为JavaScript。

function countDuplicates(n, arr) {
  var count = 0;
  arr.sort();
  for (var i = 0; i < n;) {
    if (arr[i] === arr[i + 1]) {
      count++;
      i = i + 2;
    } else {
      i++;
    }
  }
  return count;
}
console.log(countDuplicates(9, [10, 20, 20, 10, 10, 30, 50, 10, 20]));

这里有一些更简洁的答案，但这里是我为您提供的解决方案：

function countDuplicates(arr) {
  var counts = {}, sum = 0;
  for (var i = 0; i < arr.length; i++) {
    counts[arr[i].toString()] = (counts[arr[i].toString()] || 0) + 1;
  }
  for (var count in counts) {
    if (Object.prototype.hasOwnProperty.call(counts, count)) sum += Math.floor(counts[count] / 2);
  }
  return sum;
}

console.log(countDuplicates([10, 20, 20, 10, 10, 30, 50, 10, 20]));

我希望我帮上忙了

function numberOfPairs(array) {
  let arr = [...array].sort();
  let result = 0;
  
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] == arr[i + 1]) {
      result++;
      arr.shift();
    }
  }

  console.log(result);
}

numberOfPairs(['blue', 'blue', 'blue', 1, 2, 5, 2, 1]);

let pairs =0; 
ar.sort(function(a, b){return a - b});
while(n>0){
let x=ar[1];
let y=ar.shift();
n-=1;
if (y === x) {
     pairs +=1;
    ar = ar.slice(1);
    n-=1;      
 } 
}

return pairs;