Sortieren Sie ein Javascript-Array nach Häufigkeit und dann Filter wiederholt

Question

Was ist eine elegante Möglichkeit, ein Javascript-Array, nach der Häufigkeit der Werte und Filter für Uniques?

So

["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"]

wird

["oranges, "bananas", "apples"]

Answer 1

Berechnen Sie die Frequenz der einzelnen Elemente zuerst.

{ 
    apples: 1, 
    oranges: 4, 
    bananas: 2 
} 

Dann erstellen Sie ein Array von diesem Frequenzobjekt, das auch die Duplikate entfernt.

["apples", "oranges", "bananas"] 

Jetzt sortieren Sie dieses Array in absteigender Reihenfolge mit der Frequenzkarte, die wir zuvor erstellt haben.

function compareFrequency(a, b) { 
    return frequency[b] - frequency[a]; 
} 

array.sort(compareFrequency); 

Hier ist die gesamte Quelle (die neu eingeführte Array functions in ECMA 5 verwendet wird) und Kombinieren der De-Duplikation und -frequenz Kartenerzeugungsschritte,

function sortByFrequency(array) { 
    var frequency = {}; 

    array.forEach(function(value) { frequency[value] = 0; }); 

    var uniques = array.filter(function(value) { 
     return ++frequency[value] == 1; 
    }); 

    return uniques.sort(function(a, b) { 
     return frequency[b] - frequency[a]; 
    }); 
} 

Wie oben, die regelmäßige Anordnung Iteration verwendet wird.

function sortByFrequencyAndRemoveDuplicates(array) { 
    var frequency = {}, value; 

    // compute frequencies of each value 
    for(var i = 0; i < array.length; i++) { 
     value = array[i]; 
     if(value in frequency) { 
      frequency[value]++; 
     } 
     else { 
      frequency[value] = 1; 
     } 
    } 

    // make array from the frequency object to de-duplicate 
    var uniques = []; 
    for(value in frequency) { 
     uniques.push(value); 
    } 

    // sort the uniques array in descending order by frequency 
    function compareFrequency(a, b) { 
     return frequency[b] - frequency[a]; 
    } 

    return uniques.sort(compareFrequency); 
} 

Answer 2

Grundstrategie:

ein Objekt erstellen als eine Hash-Tabelle zu verwenden, um die Frequenz jedes Element in dem Array zu verfolgen, sortiert werden.

Erstellen Sie ein neues Array mit dem Element, Frequenzpaare.

Dieses Array nach Häufigkeit in absteigender Reihenfolge sortieren.

Extrahieren Sie die Elemente aus diesem Array.

Code:

function descendingUniqueSort(toBeSorted) { 
    var hash = new Object(); 
    toBeSorted.forEach(function (element, index, array) { 
          if (hash[element] == undefined) { 
           hash[element] = 1; 
          } 
          else { 
           hash[element] +=1; 
          }}); 
    var itemCounts = new Array(); 
    for (var key in hash) { 
     var itemCount = new Object(); 
     itemCount.key = key; 
     itemCount.count = hash[key]; 
     itemCounts.push(itemCount); 
    } 
    itemCounts.sort(function(a,b) { if(a.count<b.count) return 1; 
     else if (a.count>b.count) return -1; else return 0;}); 

    return itemCounts.map(function(itemCount) { return itemCount.key; }); 
} 

Answer 3

Ich war tatsächlich in der gleichen Zeit daran gearbeitet - die Lösung kam ich mit ist ziemlich identisch mit Anurag ist.

Allerdings dachte ich, es könnte es wert sein, geteilt zu werden, da ich eine etwas andere Art hatte, die Häufigkeit von Vorkommnissen zu berechnen, indem ich den ternären Operator verwendete und prüfte, ob der Wert noch etwas anders gezählt wurde.

function sortByFrequencyAndFilter(myArray) 
{ 
    var newArray = []; 
    var freq = {}; 

    //Count Frequency of Occurances 
    var i=myArray.length-1; 
    for (var i;i>-1;i--) 
    { 
     var value = myArray[i]; 
     freq[value]==null?freq[value]=1:freq[value]++; 
    } 

    //Create Array of Filtered Values 
    for (var value in freq) 
    { 
     newArray.push(value); 
    } 

    //Define Sort Function and Return Sorted Results 
    function compareFreq(a,b) 
    { 
     return freq[b]-freq[a]; 
    } 

    return newArray.sort(compareFreq); 
} 

Answer 4

// häufigste kehrt in seltensten

Array.prototype.byCount= function(){ 
    var itm, a= [], L= this.length, o= {}; 
    for(var i= 0; i<L; i++){ 
     itm= this[i]; 
     if(!itm) continue; 
     if(o[itm]== undefined) o[itm]= 1; 
     else ++o[itm]; 
    } 
    for(var p in o) a[a.length]= p; 
    return a.sort(function(a, b){ 
     return o[b]-o[a]; 
    }); 
} 

// test

var A= ["apples","oranges","oranges","oranges","bananas","bananas","oranges"]; 
A.byCount() 

/* Rückgabewert: (Array) Orangen, Bananen, Äpfel */

Answer 5

var arr = ["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"].sort(); 
var freq = {}; 
for (var s in arr) freq[s] = freq[s] ? freq[s] + 1 : 0; 
arr.sort(function(a, b) { return freq[a] > freq[b] ? -1 : 1; }); 
for (var i = arr.length - 1; i > 0; i--) if (arr[i] == arr[i - 1]) arr.splice(i,1); 
alert(arr.join(",")); 

Answer 6

für den ersten Schritt

{ 
    oranges: 4, 
    bananas: 2, 
    apples: 1 
} 

Sie countBy Funktion von underscroe.js

var all=["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"]; 
var frequency=_.countBy(all,function(each){return each}); 

so frequency Objektfrequenz aller eindeutigen Werte berechnen enthalten können, und Sie können einfach durch eine eindeutige Liste erhalten _.uniq(all) Aufruf, und dass eindeutige Liste der _.sortBy Methode von Unterstrichen zu sortieren und mit Ihrem frequency Objekt können Sie

verwenden

_.sortBy(_.uniq(all),function(frequencyKey){return -frequency[frequencyKey]}); 

-ve Hier wird das Zeichen verwendet, um die Liste in der Reihenfolge nach dem Häufigkeitswert gemäß Ihrer Anforderung zu sortieren.

können Sie überprüfen die in der Dokumentation von http://underscorejs.org/ für eine weitere Optimierung durch Ihren eigenen Trick :)

Answer 7

Für ES6, einfach Codes mit .filter und .sort wie unten

> var arr = ["apples", "oranges", "oranges", "oranges", "bananas", "bananas", "oranges"]; 
> arr.filter((key, idx) => arr.lastIndexOf(key) === idx).sort((a, b) => a < b ? -1 : 1); 
    ["apples", "bananas", "oranges"]