Найдите повторяющиеся пары в массиве

Question

У меня есть массив a = [1,1,1,2,2,3,3,3,4,4,4,6,6,6,7,7] Я хочу получить все повторяющиеся пары в этом списке массивов. Поскольку есть пары из 2 и 7, вывод должен быть -

Вывод: [2, 7]

Я попытался написать свой собственный logi c, но я очень слаб в этой области. Может кто-нибудь поможет?

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);

Таким образом, если у вас есть четыре единицы (ie: две пары единиц), фильтр уловит это, позволяя вам сопоставить [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

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]

Answer 5

Javascript имеет замечательный объект JSON, на мой взгляд, вы можете использовать json как словарь;

{ key: _value }. L oop выбросить массив один раз, без сортировки, без среза

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 6

Это даст вам желаемые пары. при вводе [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 7

Вот go:

 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 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

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 10

Вы можете сначала подсчитать появление каждого числа, и если оно больше 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)