Получить элемент, который появляется в массиве чаще всего

Question

var store = ['1','2','2','3','4'];

Я хочу узнать, что 2 появляется больше всего в массиве. Как мне это сделать?

Answer 1

Я бы сделал что-то вроде:

var store = ['1','2','2','3','4'];
var frequency = {};  // array of frequency.
var max = 0;  // holds the max frequency.
var result;   // holds the max frequency element.
for(var v in store) {
        frequency[store[v]]=(frequency[store[v]] || 0)+1; // increment frequency.
        if(frequency[store[v]] > max) { // is this frequency > max so far ?
                max = frequency[store[v]];  // update max.
                result = store[v];          // update result.
        }
}

Answer 2

Решение с акцентом на Array.prototype.forEach и проблема получения более одного ключа, если максимальный счет распределяется между несколькими элементами.

Редактировать: предложение только с одним циклом.

var store = ['1', '2', '2', '3', '4', '5', '5'],
    distribution = {},
    max = 0,
    result = [];

store.forEach(function (a) {
    distribution[a] = (distribution[a] || 0) + 1;
    if (distribution[a] > max) {
        max = distribution[a];
        result = [a];
        return;
    }
    if (distribution[a] === max) {
        result.push(a);
    }
});
console.log('max: ' + max);
console.log('key/s with max count: ' + JSON.stringify(result));
console.log(distribution);

Answer 3

arr.sort();
    var max=0,result,freq = 0;
    for(var i=0; i < arr.length; i++){
        if(arr[i]===arr[i+1]){
            freq++;
        }
        else {
            freq=0;
        }
        if(freq>max){
            result = arr[i];
            max = freq;
        }
    }
    return result;

Answer 4

Составьте гистограмму, найдите ключ для максимального числа в гистограмме.

var hist = [];
for (var i = 0; i < store.length; i++) {
  var n = store[i];
  if (hist[n] === undefined) hist[n] = 0;
  else hist[n]++;
}

var best_count = hist[store[0]];
var best = store[0];
for (var i = 0; i < store.length; i++) {
  if (hist[store[i]] > best_count) {
    best_count = hist[store[i]];
    best = store[i];
  }
}

alert(best + ' occurs the most at ' + best_count + ' occurrences');

Предполагается, что связи отсутствуют, или вам все равно, какой из них выбран.

Answer 5

Если массив отсортирован, это должно работать:

function popular(array) { 
   if (array.length == 0) return [null, 0];
   var n = max = 1, maxNum = array[0], pv, cv;

   for(var i = 0; i < array.length; i++, pv = array[i-1], cv = array[i]) {
      if (pv == cv) { 
        if (++n >= max) {
           max = n; maxNum = cv;
        }
      } else n = 1;
   }

   return [maxNum, max];
};

popular([1,2,2,3,4,9,9,9,9,1,1])
[9, 4]

popular([1,2,2,3,4,9,9,9,9,1,1,10,10,10,10,10])
[10, 5]

Answer 6

Все решения, приведенные выше, являются итеративными.

Вот версия ES6 без мутаций:

Array.prototype.mostRepresented = function() {
  const indexedElements = this.reduce((result, element) => {
    return result.map(el => {
      return {
        value: el.value,
        count: el.count + (el.value === element ? 1 : 0),
      };
    }).concat(result.some(el => el.value === element) ? [] : {value: element, count: 1});
  }, []);
  return (indexedElements.slice(1).reduce(
    (result, indexedElement) => (indexedElement.count > result.count ? indexedElement : result),
    indexedElements[0]) || {}).value;
};

Он может быть оптимизирован в определенных ситуациях, когда производительность является узким местом, но он имеет большое преимущество работы с любым видом элементов массива.

Последняя строка может быть заменена на:

  return (indexedElements.maxBy(el => el.count) || {}).value;

С:

Array.prototype.maxBy = function(fn) {
  return this.slice(1).reduce((result, element) => (fn(element) > fn(result) ? element : result), this[0]);
};

для наглядности

Answer 7

Это решение возвращает массив самых появляющихся чисел в массиве, если несколько чисел появляются в «максимальное» время.

Answer 8

Это мое решение.

var max_frequent_elements = function(arr){
var a = [], b = [], prev;
arr.sort();
for ( var i = 0; i < arr.length; i++ ) {
    if ( arr[i] !== prev ) {
        a.push(arr[i]);
        b.push(1);
    } else {
        b[b.length-1]++;
    }
    prev = arr[i];
}


var max = b[0]
for(var p=1;p<b.length;p++){
       if(b[p]>max)max=b[p]
 }

var indices = []
for(var q=0;q<a.length;q++){
   if(b[q]==max){indices.push(a[q])}
}
return indices;

};

Answer 9

Довольно короткое решение.

function mostCommon(list) {
  var keyCounts = {};
  var topCount = 0;
  var topKey = {};
  list.forEach(function(item, val) {
    keyCounts[item] = keyCounts[item] + 1 || 1;
    if (keyCounts[item] > topCount) {
      topKey = item;
      topCount = keyCounts[item];
    }
  });

  return topKey;
}

document.write(mostCommon(['AA', 'AA', 'AB', 'AC']))

Answer 10

Я решил это таким образом, чтобы найти наиболее распространенное целое число

function mostCommon(arr) {
    // finds the first most common integer, doesn't account for 2 equally common integers (a tie)

    freq = [];

    // set all frequency counts to 0
    for(i = 0; i < arr[arr.length-1]; i++) {
      freq[i] = 0;
    }

    // use index in freq to represent the number, and the value at the index represent the frequency count 
    for(i = 0; i < arr.length; i++) {
      freq[arr[i]]++; 
    }

    // find biggest number's index, that's the most frequent integer
    mostCommon = freq[0];
    for(i = 0; i < freq.length; i++) {
      if(freq[i] > mostCommon) {
        mostCommon = i;
      }
    }

    return mostCommon;
}