Get all elements of array with same (highest) occurrence

Question

I have an array like [1,4,3,1,6,5,1,4,4]

Here Highest element frequency is 3 ,I need to select all elements from array that have 3 frequency like [1,4] in above example.

I have tried with this

var count = {},array=[1,4,3,1,6,5,1,4,4],
    value;
 for (var i = 0; i < array.length; i++) {
            value = array[i];
            if (value in count) {
                count[value]++;
            } else {
                count[value] = 1;
            }
        }
console.log(count);

this will output array element with their frequency , now i need all elements that have highest frequency.

Answer 1

A proposal with Array.prototype.reduce() for a temporary object count, Object.keys() for getting the keys of the temporary object, a Array.prototype.sort() method for ordering the count results and Array.prototype.filter() for getting only the top values with the most count.

Edit: Kudos @Xotic750, now the original values are returned.

var array = [1, 4, 3, 1, 6, 5, 1, 4, 4],
    result = function () {
        var temp = array.reduce(function (r, a, i) {
            r[a] = r[a] || { count: 0, value: a };
            r[a].count++;
            return r;
        }, {});
        return Object.keys(temp).sort(function (a, b) {
            return temp[b].count - temp[a].count;
        }).filter(function (a, _, aa) {
            return temp[aa[0]].count === temp[a].count;
        }).map(function (a) {
            return temp[a].value;
        });
    }();

document.write('<pre>' + JSON.stringify(result, 0, 4) + '</pre>');

Bonus with a different attempt

var array = [1, 4, 3, 1, 6, 5, 1, 4, 4],
    result = array.reduce(function (r, a) {
        r.some(function (b, i) {
            var p = b.indexOf(a);
            if (~p) {
                b.splice(p, 1);
                r[i + 1] = r[i + 1] || [];
                r[i + 1].push(a);
                return true;
            }
        }) || (
            r[1] = r[1] || [],
            r[1].push(a)
        );
        return r;
    }, []).pop();

document.write('<pre>' + JSON.stringify(result, 0, 4) + '</pre>');

Answer 2

I'd approach this problem as follows.

First, write down how you think the problem can be solved IN ENGLISH, or something close to English (or your native language of course!). Write down each step. Start off with a high-level version, such as:

1. Count the frequency of each element in the input.

2. Find the highest frequency.

and so on. At this point, it's important that you don't get bogged down in implementation details. Your solution should be applicable to almost any programming language.

Next flesh out each step by adding substeps. For instance, you might write:

1. Find the highest frequency.

   a. Assume the highest frequency is zero.

   b. Examine each frequency. If it is higher than the current highest frqeuency, make it the current highest frequency.

Test your algorithm by executing it manually in your head.

Next, convert what you have written about into what is sometimes called pseudo-code. It is at this point that our algorithm starts to look a little bit like a computer program, but is still easily human-readable. We may now use variables to represent things. For instance, we could write "max_freq ← cur_freq". We can refer to arrays, and write loops.

Finally, convert your pseudo-code into JS. If all goes well, it should work the first time around!

In recent years, a lot of people are jumping right into JavaScript, without any exposure to how to think about algorithms, even simple ones. They imagine that somehow they need to be able to, or will magically get to the point where they can, conjure up JS out of thin air, like someone speaking in tongues. In fact, the best programmers do not instantly start writing array.reduce when confronted with a problem; they always go through the process--even if only in their heads--of thinking about the approach to the problem, and this is an approach well worth learning from.

If you do not acquire this skill, you will spend the rest of your career posting to SO each time you can't bend your mind around a problem.

Answer 3

I'm very much with what @torazaburo had to say.

I'm also becoming a fan of ES6 as it creeps more and more into my daily browser. So, here is a solution using ES6 that is working in my browser now.

The shims are loaded to fix browser browser bugs and deficiencies, which is recommended in all environments.

'use strict';
// Your array of values.
const array = [1, 4, 3, 1, 6, 5, 1, 4, 4];
// An ES6 Map, for counting the frequencies of your values.
// Capable of distinguishing all unique values except `+0` and `-0`
// i.e. SameValueZero (see ES6 specification for explanation)
const frequencies = new Map();
// Loop through all the `values` of `array`
for (let item of array) {
  // If item exists in frequencies increment the count or set the count to `1`
  frequencies.set(item, frequencies.has(item) ? frequencies.get(item) + 1 : 1);
}
// Array to group the frequencies into list of `values`
const groups = [];
// Loop through the frequencies
for (let item of frequencies) {
  // The `key` of the `entries` iterator is the value
  const value = item[0];
  // The `value` of the `entries` iterator is the frequency
  const frequency = item[1];
  // If the group exists then append the `value`,
  // otherwise add a new group containing `value`
  if (groups[frequency]) {
    groups[frequency].push(value);
  } else {
    groups[frequency] = [value];
  }
}
// The most frequent values are the last item of `groups`
const mostFrequent = groups.pop();
document.getElementById('out').textContent = JSON.stringify(mostFrequent);
console.log(mostFrequent);

<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.4.1/es5-shim.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/json3/3.3.2/json3.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/es6-shim/0.34.0/es6-shim.js"></script>
<pre id="out"></pre>

Answer 4

you can try this

var input = [1,4,3,1,6,5,1,4,4];

var output = {};

for ( var counter = 0; counter < input.length; counter++ )
{
   if ( !output[ input[ counter ] ] )
   {
      output[ input[ counter ] ] = 0;
   }
   output[ input[ counter ] ]++;
}

var outputArr = [];
for (var key in output)
{
  outputArr.push([key, output[key]])
}
outputArr = outputArr.sort(function(a, b) {return b[1] - a[1]})

now initial values of outputArr are the ones with highest frequency

Here is the fiddle

Check this updated fiddle (this will give the output you want)

var input = [1,4,3,1,6,5,1,4,4];

var output = {}; // this object holds the frequency of each value

for ( var counter = 0; counter < input.length; counter++ )
{
   if ( !output[ input[ counter ] ] )
   {
      output[ input[ counter ] ] = 0; //initialized to 0 if value doesn't exists
   }
   output[ input[ counter ] ]++; //increment the value with each occurence
}
var outputArr = [];
var maxValue = 0;
for (var key in output)
{
  if (  output[key] > maxValue )
  {
    maxValue = output[key]; //find out the max value 
  }
  outputArr.push([key, output[key]])
}
var finalArr = []; //this array holds only those keys whose value is same as the highest value
for ( var counter = 0; counter < outputArr.length; counter++ )
{
  if ( outputArr[ counter ][ 1 ]  == maxValue )
  {
     finalArr.push( outputArr[ counter ][ 0 ] )
  }
}

console.log( finalArr );

Answer 5

you can do like this to find count occurrence each number

var array = [1, 4, 3, 1, 6, 5, 1, 4, 4];

var frequency = array.reduce(function(sum, num) {
  if (sum[num]) {
    sum[num] = sum[num] + 1;
  } else {
    sum[num] = 1;
  }
  return sum;
}, {});

console.log(frequency)

<script src="https://getfirebug.com/firebug-lite-debug.js"></script>

Answer 6

I would do something like this. It's not tested, but it's commented for helping you to understand my approach.

// Declare your array
var initial_array = [1,4,3,1,6,5,1,4,4];

// Declare an auxiliar counter
var counter = {};

// Loop over the array
initial_array.forEach(function(item){

    // If the elements is already in counter, we increment the repetition counter.
    if counter.hasOwnProperty(item){
        counter[item] += 1;

    // If the element is not in counter, we set the repetitions to one
    }else{
        counter[item] = 1;
    }
});

// counter = {1 : 3, 4 : 3, 3 : 1, 6 : 1, 5 : 1}

// We move the object keys to an array (sorting it's more easy this way)
var sortable = [];

for (var element in counter)

    sortable.push([element, counter[element]]);

// sortable = [ [1,3], [4,3], [3,1], [6,1], [5,1] ]

// Sort the list
sortable.sort(function(a, b) {return a[1] - b[1]})

// sortable = [ [1,3], [4,3], [3,1], [6,1], [5,1] ] sorted, in this case both are equals

// The elements in the firsts positions are the elements that you are looking for

// This auxiliar variable will help you to decide the biggest frequency (not the elements with it)
higgest = 0;

// Here you will append the results
results = [];

// You loop over the sorted list starting for the elements with more frequency
sortable.forEach(function(item){

    // this condition works because we have sorted the list previously. 
    if(item[1] >= higgest){

        higgest = item[1];
        results.push(item[0]);

    }

});