ottenere l'articolo che appare il più delle volte in un array

Question

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

voglio scoprire che 2 appaiono come i più nella matrice. Come faccio a farlo?

Answer 1

vorrei fare qualcosa di simile:

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

Fare un istogramma, trovare la chiave per il numero massimo nell'istogramma.

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'); 

Questo presuppone che non vi siano vincoli o che non ti interessa quale sia selezionato.

Answer 3

Se l'array è ordinato questo dovrebbe funzionare:

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 4

Questa versione si chiuderà guardando quando il conteggio supera il numero di elementi non ancora conteggiati.

Funziona senza ordinare l'array.

Array.prototype.most= function(){ 
    var L= this.length, freq= [], unique= [], 
    tem, max= 1, index, count; 
    while(L>= max){ 
     tem= this[--L]; 
     if(unique.indexOf(tem)== -1){ 
      unique.push(tem); 
      index= -1, count= 0; 
      while((index= this.indexOf(tem, index+1))!= -1){ 
       ++count; 
      } 
      if(count> max){ 
       freq= [tem]; 
       max= count; 
      } 
      else if(count== max) freq.push(tem); 
     } 
    } 
    return [freq, max]; 
} 

    //test 
    var A= ["apples","oranges","oranges","oranges","bananas", 
    "bananas","oranges","bananas"]; 
    alert(A.most()) // [oranges,4] 

    A.push("bananas"); 
    alert(A.most()) // [bananas,oranges,4] 

Answer 5

Se l'array contiene stringhe provare questa soluzione

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

ho risolto in questo modo per reperire il numero intero più comune

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

Answer 7

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 8

Soluzione con enfasi Array.prototype.forEach e la problema di ottenere più di una chiave se il numero massimo è condiviso tra più elementi.

Modifica: proposta con un ciclo, solo.

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 9

Una soluzione piuttosto breve.

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

Questa è la mia soluzione.

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 11

Questa soluzione restituisce un array di numeri più che compaiono in un array, nel caso in cui più numeri appaiono ai tempi "MAX".

function mode(numbers) { 
     var counterObj = {}; 
     var max = 0; 
     var result = []; 
     for(let num in numbers) { 
     counterObj[numbers[num]] = (counterObj[numbers[num]] || 0) + 1; 
     if(counterObj[numbers[num]] >= max) { 
      max = counterObj[numbers[num]]; 
     } 
     } 
     for (let num in counterObj) { 
     if(counterObj[num] == max) { 
      result.push(parseInt(num)); 
     } 
     } 
     return result; 
    } 

Answer 12

Tutte le soluzioni sopra sono iterative.

Ecco un funzionale versione mutazione-meno 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; 
}; 

Potrebbe essere ottimizzato in particolari situazioni in cui le prestazioni è il collo di bottiglia, ma ha un grande vantaggio di lavorare con qualsiasi tipo di elementi dell'array.

L'ultima riga potrebbe essere sostituito con:

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

Con:

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

per chiarezza