查找数组中的重复对

Question

我有一个数组a = [1,1,1,2,2,3,3,3,4,4,4,6,6,6,7,7] 我想获取此数组列表中的所有重复对。 由于有 2 和 7 对，输出应该是 -

输出：[2, 7]

我尝试编写自己的逻辑，但我在这方面非常薄弱。有人可以帮忙吗？

function getDuplicateArrayElements(arr){
let sorted_arr = arr.slice().sort();
let results = [];

for (let i = 0; i < sorted_arr.length; i++) {
    let matchingElementCount = 1;

    for (let j = i + 1; j < sorted_arr.length - i; j++) {
        if (sorted_arr[j] === sorted_arr[i]) {
            ++matchingElementCount;          
        } else {
            
            if(matchingElementCount % 2 === 0) {
                results.push(sorted_arr[i]);
            }
            i = j - 1;
            break;

        }
    }
}
return results; } var a = [1,1,1,2,2,3,3,3,4,6,6,6,7,7]; var duplicateValues= getDuplicateArrayElements(a);

Answer 1

您可以使用reduce 和forEach 来实现您的结果。

const arr = [1,1,1,1,2,2,3,3,3,4,4,4,6,6,6,7,7];

// Generate a hashmap from the given array for counting the frequency.
const hashMap = arr.reduce((a, c) => {
  a[c] = (a[c] || 0) + 1;
  return a;
}, {});


const pair = [];

// If the frequency is divided by 2 then push the key of the hashMap into pair array.
Object.entries(hashMap).forEach(([k, v]) => {
  if (v % 2 === 0) {
    [...Array(Math.floor(v / 2))].forEach(_ => pair.push(k));
  }
})

console.log(pair);

Answer 2

您可以获取每个数字的频率，然后过滤掉任何具有奇数频率的数字。然后，您可以.flatMap() 将频率添加到一个数组中，该数组包含您找到的每一对的编号，如下所示：

const a = [1,1,1,2,2,3,3,3,4,4,4,6,6,6,7,7];
const freq = a.reduce((m, n) => m.set(n, (m.get(n) || 0) + 1), new Map);
const res = [...freq].filter(([n, count]) => count % 2 == 0).flatMap(([n, c]) => Array(c/2).fill(n));
console.log(res);

这样，如果您有四个 1（即：两对 1），过滤器将拾取它，允许您将 [1, 4] 数组平面映射到 [1, 1] 数组，合并到更大的结果数组中。

Answer 3

您可以创建一个辅助映射并将每个数字的计数作为值，将数字本身作为键。遍历数组后，只需找到计数可被2 整除的那些：

var a = [1, 1, 1, 2, 2, 3, 3, 3, 4, 6, 6, 6, 7, 7]

function findDuplicates(arr) {

    const map = {};

    for (const curr of arr) {
        if (!map[curr]) {
            map[curr] = 0;
        }
        map[curr]++;
    }
    const res = [];
    for (const key in map) {
        if (map.hasOwnProperty(key) && map[key] % 2 === 0) {
            res.push(Number.parseInt(key));
        }
    }
    return res;
}

console.log(findDuplicates(a));

Answer 4

您可以先计算每个数字的出现次数，如果它大于 0 且可被 2 整除，则将这些添加到最终结果中，否则不要

function getDuplicateArrayElements(arr) {
  let map = {}
  let results = [];

  for (let num of arr) {
    map[num] = map[num] || 0
    map[num]++
  }
  
  return Object.keys(map)
               .filter(v => map[v] && map[v] % 2 === 0)
               .map(v => new Array(map[v]/2).fill(+v))
               .flat()
               .sort()
}

var a = [1, 1, 1, 2, 2, 3, 3, 3, 4, 6, 6, 6, 7, 7,8,8,8,8];
var duplicateValues = getDuplicateArrayElements(a);
console.log(duplicateValues)

Answer 5

const a = {};
[1,1,1,2,2,3,3,3,4,6,6,6,7,7].forEach(v => {a[v] = a[v] ? a[v] + 1 : 1});
const l = [];
Object.keys(a).forEach(k => !(a[k] % 2) && l.push(k));

Answer 6

给你：

 function getDuplicateArrayElements(arr){
    var dupilcates=arr.filter(x =>  arr.filter(y=>y==x).length==2);  
    var found=[];
    for(var i=0;i<dupilcates.length;i=i+2)
      found.push(dupilcates[i]);
    return found;
}

Answer 7

这将为您提供所需的配对。输入[1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 6, 6, 6, 6, 7, 7] 将返回[1,1,2,6,6,7]：

function getDuplicateArrayElements(arr){
  let sorted_arr = arr.slice().sort();
  let results = [];
  let i = 0;
  while (i < sorted_arr.length) {
    let counter = 1;
    let j = i;
    while (sorted_arr[j] === sorted_arr[j+1]) {
      counter++;
      j++;
    }
    
    if (counter%2 == 0) {        
      results.push(...Array(counter/2).fill(sorted_arr[i]))
    }
    
    i += counter;
  }

  return results; 
} 

var a = [1, 1, 1, 1, 2, 2, 3, 3, 3, 4, 6, 6, 6, 6, 7, 7];
console.log(getDuplicateArrayElements(a));

Answer 8

另一个相当简洁的解决方案：

a = [1,1,1,2,2,3,3,3,4,4,4,6,6,6,7,7];
uniques = new Set(a); //filter out duplicates
res = [];
uniques.forEach((key)=>{
if(a.filter(elem => elem === key).length === 2){res.push(key)}; 
//filter out only the elements which match the key being tested
//if there are 2, push to result
})

编辑：更简洁，但效率可能更低：

a = [1,1,1,2,2,3,3,3,4,4,4,6,6,6,7,7];
res = Array.from(new Set(a.filter(elem => a.filter(el => el === elem).length === 2)));

Answer 9

Javascript 有很棒的 JSON 对象，在我看来，你可以使用 json 作为字典；

{ key: _value }.
循环抛出数组一次，不排序，不切片

key是数组的元素值，_value是频率

var frequencies = {};
for (let i = 0; i < a.length; a++) {
   if (result[a[i]] == 'over') continue;
   if (result[a[i]] == undefined) { // First times
       result[a[i]] = 1
   } else if (result[a[i]] == 1) { // Second times
       result[a[i]] = 2
   } else { // Ignore if > 2
       result[a[i]] = 'over'
   }
}
// result: {1: "over", 2: 2, 3: "over", 4: "over", 6: "over", 7: 2}

所以现在选择键的值等于 2

Answer 10

function getDuplicateArrayElements(numbers: number[]): number[] {
  const occurences = new Map<number, number>();

  for (let number of numbers) {
    if (occurences.has(number)) {
      const current = occurences.get(number)!;
      occurences.set(number, current + 1);
    } else 
    occurences.set(number, 1)  
  }

  return (
    Array
      .from(occurences.entries())
      .reduce<number[]>(
        (accumulator, [key, value]) => {
          if (value === 2) {
            return accumulator.concat(key)
          }

          return accumulator
        },
        []
      )
  )
}

const a = [1, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 6, 6, 6, 7, 7];

getDuplicateArrayElements(a); // [2, 7]