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