Javascript函數。什麼不見​​了？

Question

編寫一個程序來查找數組中最頻繁項目的數量。假設輸入是整數數組。

實施例：

輸入數組：[3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]

Ouptut：5

例如在大多數頻繁數數組是-1。它在輸入數組中出現5次。

這裏是我的代碼：

function mostFrequentItemCount(collection) { 

    var copy = collection.slice(0); 

    for (var i = 0; i < collection.length; i++) { 
    var output = 0; 
    for (var x = 0; x < copy.length; x++) { 
     if (collection[i] == copy[x]) { 
     output++; 
     } 
    } 
    } 
    return output; 
} 

這似乎只是計算的第一個數字的復發陣列不發生的大多數1英寸我無法弄清楚如何讓它算出最發生的一個。

Answer 1

如果我沒有錯過任何東西，如果你真的想找到一個數組的最常見物品的數量，我想一個辦法是這樣：

function existsInCollection(item, collection) { 
 
    for(var i = 0; i < collection.length; i++) { 
 
     if(collection[i] === item) { 
 
      return true; 
 
     } 
 
    } 
 
    
 
    return false; 
 
} 
 

 
function mostFrequentItemCount(collection) { 
 
     var most_frequent_count = 0; 
 
     var item_count = 0; 
 
     var already_checked = []; 
 
     
 
     for(var i = 0; i < collection.length; i++) { 
 
      // if the item was already checked, passes to the next 
 
      if(existsInCollection(collection[i], already_checked)) { 
 
       continue; 
 
      } else { 
 
       // if it doesn't, adds to the already_checked list 
 
       already_checked.push(collection[i]); 
 
      } 
 
      
 
      for(var j = 0; j < collection.length; j++) 
 
       if(collection[j] === collection[i]) 
 
        item_count++; 
 

 
      if(item_count > most_frequent_count) 
 
       most_frequent_count = item_count; 
 

 
      item_count = 0; 
 

 
     } 
 

 
     return most_frequent_count; 
 
    } 
 
    
 
    var items = [3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]; 
 
    
 
    alert(mostFrequentItemCount(items));

這裏發生的是：

，在每個項目（「我」循環），它會通過所有項目運行另一個迴路（「J」），和算多少都等於[I]項。在第二個循環之後，將驗證該項目數是否大於我們已有的most_frequent_count，如果是，則更新它。 因爲我們總是使用相同的變量「ITEM_COUNT」來檢查每個數計，我們將其重置爲0。

這可能不是最好的答案每個數字的核實，但它發生了什麼我的那一刻，

編輯： 我添加了一個函數來檢查一個項目是否已經存在於一個列表中，以避免循環再次檢查同一個項目。

Answer 2

因此，此方法的更新將返回一個包含每個鍵的對象以及該鍵在該數組中的計數。如何格式化輸出以說明什麼樣的密鑰具有什麼數量取決於您。

編輯：更新爲包含問題的完整解決方案。

function mostFrequentItemCount(collection) { 
 
    var copy = collection.slice(0); 
 
    var results = {}; 
 
    for (var i = 0; i < collection.length; i++) { 
 
    var count = 0; 
 
    for (var x = 0; x < copy.length; x++) { 
 
     if (collection[i] == copy[x]) { 
 
     count++; 
 
     } 
 
    } 
 
    results[collection[i]] = count; 
 
    } 
 
    
 
    return results; 
 
} 
 

 
var inputArray = [3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]; 
 
var occurances = mostFrequentItemCount(inputArray); 
 
var keyWithHighestOccurance = Object.keys(occurances).reduce(function(a, b){ return occurances[a] > occurances[b] ? a : b }); 
 
var highestOccurance = occurances[keyWithHighestOccurance]; 
 
console.log("Most frequent number in example array is " + keyWithHighestOccurance + ". It occurs " + highestOccurance + " times in the input array.");

Answer 3

的問題是，你重寫output變量每次循環迭代，所以之後的for循環結束您output變量保存輸入數組的最後一個元素的出現。

您應該使用像var best_element = collection[0]和var best_element_count = -1（如此初始化）的變量。在每個內部循環之後，檢查算法是否找到了更好的解決方案（best_element_count < output）和更新best_element。

編輯：在@Alnitak評論後，您應該在每次內循環迭代後重置output變量。

Answer 4

首先，您需要構建一個包含元素和發生次數的集合（或對象）。其次，您需要迭代結果以查找具有最高值的密鑰。

JSFiddle

function mostFrequentItemCount(collection) { 
 
    var output = {}; 
 
    for (var i = 0; i < collection.length; i++) { 
 
    var item = collection[i]; 
 
    if (!(item in output)) 
 
     output[item] = 0; 
 
    output[item]++; 
 
    } 
 
    var result = [0, 5e-324]; 
 
    for (var item in output) { 
 
    if (output[item] > result[1]) { 
 
     result[0] = parseFloat(item); 
 
     result[1] = output[item]; 
 
    } 
 
    } 
 
    return result; 
 
} 
 
var input = [3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]; 
 
var result = mostFrequentItemCount(input); 
 
console.log(result);

以上只是代碼段創建一個新對象（output），其包含對於每個所述陣列中的唯一元素的屬性。結果是類似的。

2:2 
3:4 
4:1 
9:1 
-1:5 

所以現在我們有一個物體的數字和發生的值。接下來，我們將討論輸出for(var item in output)中的每個屬性，並確定哪個值最大。

現在，這將返回一個數組，其索引0處的值是數字，索引1處的值是該元素的計數。

Answer 5

檢查這個解決方案。

var store = [3, -1, -1, -1, 2, 3, -1, 3, -1, 2, 4, 9, 3]; 
 
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. 
 
     } 
 
} 
 
alert(max);