Get the item that appears the most times in an array

Question

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

I want to find out that 2 appear the most in the array. How do I go about doing that?

Answer 1

I would do something like:

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

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 3

Solution with emphasis to Array.prototype.forEach and the problem of getting more than one key if the max count is shared among more items.

Edit: Proposal with one loop, only.

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 4

All the solutions above are iterative.

Here's a ES6 functional mutation-less version:

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

It could be optimized in specific situations where performance is the bottleneck, but it has a great advantage of working with any kind of array elements.

The last line could be replaced with:

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

With:

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

for clarity

Answer 5

If the array contains strings try this solution

    function GetMaxFrequency (array) {
    var store = array;
    var frequency = [];  // array of frequency.
    var result;   // holds the max frequency element.

    for(var v in store) {
        var target = store[v];
        var numOccurences = $.grep(store, function (elem) {
        return elem === target;
        }).length;
        frequency.push(numOccurences);

    }
    maxValue = Math.max.apply(this, frequency);
    result = store[$.inArray(maxValue,frequency)];
    return result;
}
var store = ['ff','cc','cc','ff','ff','ff','ff','ff','ff','yahya','yahya','cc','yahya'];
alert(GetMaxFrequency(store));

Answer 6

I solved it this way for finding the most common integer

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