Lấy mục xuất hiện nhiều lần nhất trong một mảng

Question

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

Tôi muốn tìm hiểu rằng 2 xuất hiện nhiều nhất trong mảng. Làm thế nào để tôi làm được điều đó?

Answer 1

tôi sẽ làm một cái gì đó như:

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

Tạo biểu đồ, tìm khóa cho số tối đa trong biểu đồ.

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

Giả định này không có quan hệ hoặc bạn không quan tâm được chọn.

Answer 3

Nếu mảng được sắp xếp này nên làm việc:

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

Phiên bản này sẽ từ bỏ tìm kiếm khi đếm vượt quá số hạng mục chưa tính.

Nó hoạt động mà không cần sắp xếp mảng.

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

Nếu mảng chứa các chuỗi thử giải pháp này

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

tôi giải quyết nó theo cách này cho việc tìm kiếm các số nguyên phổ biến nhất

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

Giải pháp với sự nhấn mạnh đến Array.prototype.forEach và vấn đề nhận được nhiều hơn một khóa nếu số lượng tối đa được chia sẻ giữa các mục khác.

Chỉnh sửa: Chỉ đề xuất với một vòng lặp.

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

Một giải pháp khá ngắn.

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

Đây là giải pháp của tôi.

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

Giải pháp này trả về một mảng các số xuất hiện nhiều nhất trong một mảng, trong trường hợp nhiều số xuất hiện ở thời gian "tối đa".

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

Tất cả các giải pháp trên đều lặp lại.

Dưới đây là một ES6 chức năng đột biến ít phiên bản:

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

Nó có thể được tối ưu hóa trong các tình huống cụ thể mà thực hiện là nút cổ chai, nhưng nó có một lợi thế lớn khi làm việc với bất kỳ loại phần tử mảng.

Dòng cuối cùng có thể được thay thế bằng:

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

Với:

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

cho rõ ràng