What is a more optimized solution for this algorithm? I feel i can learn more from this question

Question

First off am a beginner practicing my JavaScript. My solution to this problem will be posted. I think its worth mentioning this took almost two days of pondering to solve The Problem: I am required to write an algorithm that will return the mode(s) from the given input array. For example:

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]

Solution:

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

If you're looking at this as a learning exercise, here's another implementation of the same algorithm from CertainPerformance, but written quite differently.

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]

If it's not clear, my counts matches to grouped and my max to maxCount.

The big difference from the answer by CertainPerformance is that this is written with pure expressions rather than statements. This is a style that I try to follow as much as I can do so practically.

It uses default parameters as a poor-man's substitute for let bindings available in other languages. It's not a perfect substitute and there is at least one potential problem with it, but it can be quite useful. Doing this let me define some helper variables that you can't assign in a function body without statements. There are alternatives, but I find this simplest when I can get away with it.

The reduce call is essentially the same as the other answer. So is the max definition.

But I take advantage of the fact that the default iterator of a Map is the list of entries, to turn the map into [[4, 1], [5, 1], [6, 3] ...] just by using the spread operator (...), without a need to call .entries().

Finally, I replace a call to filter and then to map with a single call to flatMap. This feels more elegant.

I'm not trying to suggest that this code is better than the one from CertainPerformance. It's quite similar in feel, although different in arrangement. But it is a different approach to the problem, and it might have something to offer because of that.

Answer 2

I'd count up the number of occurrences of each element into an Map. Then use Math.max to find the largest value(s) in the map, and then take the keys which are equal to that largest value:

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

A more simpler and optimized approach with single iteration

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