这个算法更优化的解决方案是什么？我觉得我可以从这个问题中学到更多

Question

首先，我是一个练习我的 JavaScript 的初学者。我对这个问题的解决方案将被发布。我认为值得一提的是这花了将近两天的时间思考才能解决 问题： 我需要编写一个算法，该算法将从给定的输入数组中返回模式。例如：

mode([4, 5, 6, 6, 6, 7, 7, 9, 10]) ➞ [6]

mode([4, 5, 5, 6, 7, 8, 8, 9, 9]) ➞ [5, 8, 9]

mode([1, 2, 2, 3, 6, 6, 7, 9]) ➞ [2, 6]

解决方案：

function mode(nums) {
  let array = [...nums]
  array = array.sort((a, b) => a - b) //sorts the array from lowest value

  // function to figure out the unique numbers and return as an array
  function uniqueNums(array) {
    let uniques = []
    for (let i = 0; i < array.length; i++) {
      if (!uniques.includes(array[i])) {
        uniques.push(array[i])
      }
    }
    return uniques
  }

  //function to return the mode of every unique number

  function counter(array) {
    let modes = []
    for (let i = 0; i < array.length; i++) {
      let count = 1, // keeps track of occurrence's of a number
        track = 1 //variable enables the while loop keep checking
      while (array[i] === array[i + track]) {
        count++
        track++
      }
      modes.push(count)
      i += count - 1
    }
    return modes
  }

  //function to return the highest mode(s)
  function highestMode(uniques, modes) {
    let highest = [],
      max = 0 //tracks our highest number in the array

    //loops to find highest mode
    for (let i = 0; i < modes.length; i++) {
      if (max < modes[i]) {
        max = modes[i]
      }
    }

    //loops to push position of modes equal to the highest mode
    for (let i = 0; i < modes.length; i++) {
      if (max === modes[i]) {
        highest.push(i)
      }
    }

    //uses the position of highest modes to swap them with their 
    //actual values
    let result = highest.map(a => a = uniques[a])
    return result
  }
  return highestMode(uniqueNums(array), counter(array))
}


console.log(mode([4, 4, 4, 6, 8, 9, 10, 10]))

Answer 1

如果您将此视为一种学习练习，这里是来自CertainPerformance 的相同算法的另一种实现，但编写方式完全不同。

const mode = (
  ns, 
  counts = ns .reduce ((m, n) => m .set (n, (m .get (n) || 0) + 1), new Map ()),
  max = Math .max (... counts .values())
) => 
  [...counts] .flatMap (([n, c]) => c == max ? [n] : [])


console .log (mode ([4, 5, 6, 6, 6, 7, 7, 9, 10])) //=> [6]
console .log (mode ([4, 5, 5, 6, 7, 8, 8, 9, 9])) //=> [5, 8, 9]
console .log (mode ([1, 2, 2, 3, 6, 6, 7, 9])) //=> [2, 6]

如果不清楚，我的counts 匹配grouped，我的max 匹配maxCount。

与CertainPerformance 的答案的最大区别在于，这是用纯表达式而不是语句编写的。这是我尽可能多地遵循的风格。

它使用默认参数代替其他语言中的let bindings。它不是一个完美的替代品，至少有一个potential problem，但它可能非常有用。这样做让我定义了一些辅助变量，如果没有语句，您无法在函数体中分配这些变量。有其他选择，但当我可以摆脱它时，我发现这个最简单。

reduce 调用与其他答案基本相同。 max 定义也是如此。

但我利用 Map 的默认迭代器是条目列表这一事实，只需使用扩展运算符 (...) 即可将映射转换为 [[4, 1], [5, 1], [6, 3] ...]，而无需调用 @987654332 @。

最后，我将调用filter 和map 替换为调用flatMap。这感觉更优雅。

我并不是要暗示这段代码比来自CertainPerformance 的代码更好。它的感觉非常相似，尽管排列方式不同。但这是解决问题的不同方法，因此它可能会提供一些东西。

Answer 2

我会将每个元素出现的次数统计到地图中。然后使用Math.max在map中找到最大值，然后取与最大值相等的key：

const mode = arr => {
  const grouped = new Map();
  for (const item of arr) {
    grouped.set(item, (grouped.get(item) || 0) + 1);
  }
  const maxCount = Math.max(...grouped.values());
  return [...grouped.entries()]
    .filter(([, count]) => count === maxCount)
    .map(([key]) => key);
};

console.log(mode([4, 5, 6, 6, 6, 7, 7, 9, 10])) // ➞ [6]
console.log(mode([4, 5, 5, 6, 7, 8, 8, 9, 9])) // ➞ [5, 8, 9]
console.log(mode([1, 2, 2, 3, 6, 6, 7, 9])) // ➞ [2, 6]

Answer 3

单次迭代的更简单和优化的方法

https://jsfiddle.net/dv7f9nxr/

function mode(items) {
  var result = [];
  var count = {};
  var highest= 0;

  items.map((item) => {
    var itemCount = (count[item] || 0) + 1;
    count[item] = itemCount;
      if(itemCount > highest) {
        highest = itemCount;
        //reset 
        result = [item];
      } else if (itemCount === highest){
        result.push(item);
    }

  })
 
  
  
  return result;
}

console.log(mode([2, 3, 9, 6, 9]))
console.log(mode([2, 3,2, 9, 6, 9]))
console.log(mode([2, 3,2, 9, 6, 9,2]))
console.log(mode([2, 3, 9, 6, 9,6,2]))