Sorting an array order by frequency of occurence in javascript

gistfile1.txt

/**
 *  Sorting an array order by frequency of occurence in javascript
 *  @param {array} array An array to sort
 *  @returns {array} array of item order by frequency
 **/
function sortByFrequency(array) {
    var frequency = {};
    var sortAble = [];
    var newArr = [];

    array.forEach(function(value) { 
        if ( value in frequency )
            frequency[value] = frequency[value] + 1;
        else
            frequency[value] = 1;
    });
    

    for(var key in frequency){
        sortAble.push([key, frequency[key]])
    }

    sortAble.sort(function(a, b){
        return b[1] - a[1]
    })

    
    sortAble.forEach(function(obj){
        for(var i=0; i < obj[1]; i++){
            newArr.push(obj[0]);
        }
    })
    return newArr;
    
}

gistfile2.txt

Example Suppose you have an array [2, 2, 1, 4, 2,5, 4,4,4, 5]

sortByFrequency([2, 2, 1, 4, 2,5, 4,4,4, 5])

Answer : [ '4', '4', '4', '4', '2', '2', '2', '5', '5', '1' ]

Looks good but not sorted with index for sorting same count

function sortByFrequency(array) {
    var frequency = {};
    var sortAble = [];
    var newArr = [];

    array.forEach(function(value, i) {
      frequency[value] = {
        occurance: (frequency[value] && frequency[value].occurance || 0) + 1,
        index: frequency[value] && frequency[value].index !== undefined && frequency[value].index < i ? frequency[value].index : i
      };
    });
  

    for(var key in frequency){
        sortAble.push([key, frequency[key].occurance, frequency[key].index])
    }
  
    sortAble.sort(function(a, b){
      if (a[1] === b[1]) {
        return a[2] - b[2]
      }
      return b[1] - a[1]
    })
    
    sortAble.forEach(function(obj){
        for(var i=0; i < obj[1]; i++){
            newArr.push(obj[0]);
        }
    })
  
    return newArr;
    
}

function sortByFrequency(arr){
  const frequency = {};
  arr.forEach(item => {
      frequency[item] = (frequency[item] || 0) + 1;
  });
  const sortable = arr.map(item => [item, frequency[item]]);
  sortable.sort((a,b) => {
    if (a[1] === b[1]) return a[0] - b[0];
    return b[1] - a[1];
  });
  return sortable.map(s => s[0]);
}

function sortByFrequency(arr){
    const frequencyMap = arr.reduce((obj, item) => {
        obj[item] = (obj[item] || 0) + 1
        return obj;
    }, {});

    return Object.entries(frequencyMap).sort((a,b) => b[1] - a[1]).flatMap(arr => Array(arr[1]).fill(arr[0]));
  }

This snippet actually helped me to understand the more widespread usage of reduce. Thanks.

function SortElemByFrequencyObj(arr) {
    const frequency = arr.reduce((obj, curr) => {
        obj[curr] = (obj[curr] || 0) + 1;
        return obj;
    }, {});
    return Object.entries(frequency).sort((a, b) => b[1] - a[1]).flatMap(item => Array(item[1]).fill(item[0]))
}

let input = [1, 2, 3, 5, 1, 5, 1, 3, 5, 1];
let sortedArray = input.sort((a, b) => a - b);
let diff = [];

for (let i = 0; i < sortedArray.length; i++) {
diff.push({
d:
sortedArray.lastIndexOf(sortedArray[i]) -
sortedArray.indexOf(sortedArray[i]) +
1,
s: sortedArray[i],
});
i = i + sortedArray.lastIndexOf(sortedArray[i]);
}

let store = diff.sort((a, b) => (a.d < b.d ? 1 : -1));

let new1 = [];

store.forEach((el) => {
while (el.d > 0) {
// console.log(el.s);
new1.push(el.s);
el.d--;
}
});

console.log(new1);

function SortElemByFrequencyObj(arr) {
const frequency = arr.reduce((obj, curr) => {
obj[curr] = (obj[curr] || 0) + 1;
return obj;
}, {});
return Object.entries(frequency).sort((a, b) => b[1] - a[1]).flatMap(item => Array(item[1]).fill(item[0]))
}

you can make this code compact by using lodash _.count method

import _ from 'lodash';
function SortElemByFrequencyObj(arr) {
const frequency = _.count(arr);
return Object.entries(frequency).sort((a, b) => b[1] - a[1]).flatMap(item => Array(item[1]).fill(item[0]));
}