Get the element with the highest occurrence in an array

Question

I m looking for an elegant way of determining which element has the highest occurrence  mode  in a JavaScript array    For example  in    pear    apple    orange    apple     the  apple  element is the most frequent one

User · Answer

Try it too  this does not take in account browser version   function mode arr   var a      b   0 occurrence      for var i   0  i  lt  arr length i         if a arr i      undefined           a arr i           else          a arr i     1                  for var key in a       if a key   gt  b           b   a key           occurrence   key              return occurrence    alert mode   segunda   ter  a   terca   segunda   ter  a   segunda           Please note that this function returns latest occurence in the array   when 2 or more entries appear same number of times

User · Answer

Can try    var arr    10 3 4 5 3 4 3 8 3 6 3 5 1   var temp        for let i 0 i lt arr length i         if temp arr i    undefined          temp arr i   1       else          temp arr i    1           var max 0  maxEle   for const i in temp       if temp i  gt max           max   temp i           maxEle i           console log  most occurred element is   maxEle  and number of times is   max

User · Answer

var cats     Tom   Fluffy   Tom   Bella   Chloe   Tom   Chloe    var counts       var compare   0  var mostFrequent   function array      for var i   0  len   array length  i  lt  len  i            var word   array i           if counts word      undefined              counts word    1          else             counts word    counts word    1                  if counts word   gt  compare                compare   counts word                mostFrequent   cats i                    return mostFrequent     cats

User · Answer

Time for another solution   function getMaxOccurrence arr        var o       maxCount   0  maxValue  m      for  var i 0  iLen arr length  i lt iLen  i              m   arr i            if   o hasOwnProperty m                 o m    0                      o m            if  o m   gt  maxCount                maxCount   o m               maxValue   m                      return maxValue      If brevity matters  it doesn t   then   function getMaxOccurrence a        var o       mC   0  mV  m      for  var i 0  iL a length  i lt iL  i              m   a i           o hasOwnProperty m     o m    o m    1          if  o m   gt  mC  mC   o m   mV   m            return mV      If non   existent members are to be avoided  e g  sparse array   an additional hasOwnProperty test is required   function getMaxOccurrence a        var o       mC   0  mV  m      for  var i 0  iL a length  i lt iL  i              if  a hasOwnProperty i                 m   a i               o hasOwnProperty m     o m    o m    1              if  o m   gt  mC  mC   o m   mV   m                      return mV     getMaxOccurrence       1 1       1   Other answers here will return undefined

User · Answer

As per George Jempty s request to have the algorithm account for ties  I propose a modified version of Matthew Flaschen s algorithm   function modeString array      if  array length    0  return null     var modeMap           maxEl   array 0       maxCount   1     for  var i   0  i  lt  array length  i          var el   array i        if  modeMap el     null  modeMap el    1      else modeMap el          if  modeMap el   gt  maxCount          maxEl   el        maxCount   modeMap el         else if  modeMap el     maxCount          maxEl      amp     el        maxCount   modeMap el               return maxEl      This will now return a string with the mode element s  delimited by a  amp  symbol  When the result is received it can be split on that  amp  element and you have your mode s     Another option would be to return an array of mode element s  like so   function modeArray array      if  array length    0  return null    var modeMap           maxCount   1      modes          for  var i   0  i  lt  array length  i          var el   array i        if  modeMap el     null  modeMap el    1      else modeMap el          if  modeMap el   gt  maxCount          modes    el         maxCount   modeMap el         else if  modeMap el     maxCount          modes push el         maxCount   modeMap el               return modes      In the above example you would then be able to handle the result of the function as an array of modes

User · Answer

Another JS solution from  https   www w3resource com javascript-exercises javascript-array-exercise-8 php  Can try this too   let arr    pear    apple    orange    apple     function findMostFrequent arr      let mf   1    let m   0    let item     for  let i   0  i  lt  arr length  i          for  let j   i  j  lt  arr length  j            if  arr i     arr j             m            if  m  gt  mf              mf   m            item   arr i                               m   0         return item     findMostFrequent arr      apple

User · Answer

Here is another ES6 way of doing it with O n  complexity  const result   Object entries        pear    apple    orange    apple   reduce  previous  current    gt            if  previous current      undefined  previous current    1          else previous current             return previous              reduce  previous  current    gt   current 1   gt   previous 1    current   previous   0   console log  Max value       result

User · Answer

This function is generic function for every type of info  It counts the occurrence of the elements and then returns array with maximum occurring elements    function mode        var arr      slice call arguments     if   args length    1   amp  amp   typeof args 0       object          args   args 0  mode           var obj         for var i   0  i  lt  arr length  i          if obj arr i       undefined  obj arr i     1      else obj arr i             var max   0    for  w in obj        if  obj w   gt  max  max   obj w          ret val         for  w in obj        if  obj w     max  ret val push w          return ret val

User · Answer

function mode array       var set   Array from new Set array        var counts   set map a  gt array filter b  gt b  a  length       var indices   counts map  a b   gt Math max    counts    a b 0  filter b  gt b   0       var mode   indices map a  gt set a        return mode

User · Answer

I came up with a shorter solution  but it s using lodash  Works with any data  not just strings  For objects can be used  const mostFrequent     maxBy Object values   groupBy inputArr  el   gt  el someUniqueProp    arr   gt  arr length  0    This is for strings  const mostFrequent     maxBy Object values   groupBy inputArr  el   gt  el    arr   gt  arr length  0    Just grouping data under a certain criteria  then finding the largest group

User · Answer

Here is my way to do it so just using  filter   x000D   x000D  var arr     pear    apple    orange    apple     function dup arrr        let max     item  0  count  0        for  let i   0  i  lt  arrr length  i              let arrOccurences   arrr filter item   gt    return item     arrr i     length          if  arrOccurences  gt  max count                max     item  arrr i   count  arrr filter item   gt    return item     arrr i     length                        return max item    console log dup arr    x000D   x000D   x000D

User · Answer

This solution can return multiple elements of an array in case of a tie  For example  an array arr     3  4  3  6  4      has two mode values  3 and 6  Here is the solution  function find mode arr        var max   0      var maxarr           var counter           var maxarr            arr forEach function           counter push 0                for var i   0 i lt arr length i            for var j 0 j lt arr length j                 if arr i   arr j  counter i                            max this arrayMax counter             for var i   0 i lt arr length i              if counter i   max maxarr push arr i               var unique   maxarr filter  this onlyUnique        return unique          function arrayMax arr          var len   arr length  max   -Infinity        while  len--                  if  arr len   gt  max                  max   arr len                             return max        function onlyUnique value  index  self           return self indexOf value      index

User · Answer

You could solve it in O n  complexity  var arr    1 3 54 56 6 6 1 6   var obj           first convert the array in to object with unique elements and number of times each element is repeated    for var i   0  i  lt  arr length  i         var x   arr i      if  obj x        obj x    1     else       obj x        console log obj    just for reference     now traverse the object to get the element    var index   0  var max   0   for var obIndex in obj      if obj obIndex   gt  max          max   obj obIndex       index   obIndex        console log index   got maximum time repeated  with    max    times       Just copy and paste in chrome console to run the above code

User · Answer

Here is my solution  -   x000D   x000D  function frequent number   x000D      var count   0  x000D      var sortedNumber   number sort    x000D      var start   number 0   item  x000D      for var i   0    i  lt  sortedNumber length  i     x000D        if start     sortedNumber i     sortedNumber i      sortedNumber i 1    x000D           item   sortedNumber i  x000D          x000D        x000D      return item x000D     x000D    x000D   x000D     console log  frequent   pear    apple    orange    apple     x000D   x000D   x000D

User · Answer

const mode    str    gt      return str      split           reduce  data  key    gt          let counter   data map key    1    1       data map key    counter        if  counter  gt  data counter            data counter   counter         data mode   key                return data                counter  0        mode  null        map                 mode    console log mode  the t-rex is the greatest of them all

User · Answer

Here   s the modern version using built-in maps  so it works on more than things that can be converted to unique strings     x000D   x000D   use strict   x000D   x000D  const histogram   iterable   gt    x000D      const result   new Map    x000D   x000D      for  const x of iterable    x000D          result set x   result get x     0    1   x000D        x000D   x000D      return result  x000D     x000D   x000D  const mostCommon   iterable   gt    x000D      let maxCount   0  x000D      let maxKey  x000D   x000D      for  const  key  count  of histogram iterable     x000D          if  count  gt  maxCount    x000D              maxCount   count  x000D              maxKey   key  x000D            x000D        x000D   x000D      return maxKey  x000D     x000D   x000D  console log mostCommon   pear    apple    orange    apple      x000D   x000D   x000D

User · Answer

I guess you have two approaches  Both of which have advantages   Sort then Count or Loop through and use a hash table to do the counting for you    The hashtable is nice because once you are done processing you also have all the distinct elements  If you had millions of items though  the hash table could end up using a lot of memory if the duplication rate is low  The sort  then count approach would have a much more controllable memory footprint

User · Answer

O n  var arr    1  2  3  2  3  3  5  6   var duplicates       max       maxi   0  arr forEach  el    gt        duplicates el    duplicates el    1    1    if  maxi  lt  duplicates el         max   el      maxi   duplicates el           console log max

User · Answer

var mode   0  var c   0  var num   new Array    var value   0  var greatest   0  var ct   0    Note  ct is the length of the array   function getMode         for  var i   0  i  lt  ct  i                  value   num i           if  i    ct                        while  value    num i   1                                 c   c   1                  i   i   1                                  if  c  gt  greatest                        greatest   c              mode   value                    c   0

User · Answer

There have been some developments in javascript since 2009 - I thought I d add another option   I m less concerned with efficiency until it s actually a problem so my definition of  elegant  code  as stipulated by the OP  favours readability - which is of course subjective     function mode arr       return arr sort  a b    gt            arr filter v   gt  v   a  length         - arr filter v   gt  v   b  length       pop       mode   pear    apple    orange    apple        apple   In this particular example  should two or more elements of the set have equal occurrences then the one that appears latest in the array will be returned   It s also worth pointing out that it will modify your original array - which can be prevented if you wish with an  Array slice call beforehand     Edit  updated the example with some ES6 fat arrows because 2015 happened and I think they look pretty    If you are concerned with backwards compatibility you can find this in the revision history

User · Answer

You can try this       using splice          get the element with the highest occurence in an array     function mc a          var us       l           find all the unique elements in the array       a forEach function  v            if  us indexOf v      -1              us push v                             l   us length        while  true            for  var i   0  i  lt  l  i                 if  a indexOf us i       -1                continue              else if  a indexOf us i      -1  amp  amp  a length  gt  1                   just delete it once at a time             a splice a indexOf us i    1               else                  default to last one             return a 0                                           using string match method function su a        var s   a join                uelms                   r                   l              i              m       a forEach function  v            if  uelms indexOf v      -1                uelms push v                          l   uelms length          use match to calculate occurance times     for  i   0  i  lt  l  i               r uelms i     s match new RegExp uelms i    g    length             m   uelms 0       for  var p in r            if  r p   gt  r m                 m   p            else               continue                       return m

User · Answer

This is just the mode   Here s a quick  non-optimized solution   It should be O n    function mode array        if array length    0          return null      var modeMap           var maxEl   array 0   maxCount   1      for var i   0  i  lt  array length  i                  var el   array i           if modeMap el     null              modeMap el    1          else             modeMap el               if modeMap el   gt  maxCount                        maxEl   el              maxCount   modeMap el                       return maxEl

User · Answer

Here is my way  I try to group data fist    const     require  underscore    var test      1  1  2  1    var groupResult     groupBy test   e   gt  e     The groupResult should be       1   1  1  1    2   2       Then find the property which has the longest array  function findMax groupResult      var maxArr         var max     for var item in groupResult        if  max             max     value item  count  groupResult item  length              maxArr push max            continue              if max count  lt  groupResult item  length            maxArr               max     value item  count  groupResult item  length           maxArr push max         else if max     groupResult item  length          maxArr push   value item  count  groupResult item  length            return maxArr      The complete code looks like  const     require  underscore    var test      1  1  2  1    var groupResult    groupBy test   e   gt  e   console log findMax groupResult  0  value    function findMax groupResult      var maxArr         var max     for var item in groupResult        if  max             max     value item  count  groupResult item  length              maxArr push max            continue              if max count  lt  groupResult item  length            maxArr               max     value item  count  groupResult item  length           maxArr push max         else if max     groupResult item  length          maxArr push   value item  count  groupResult item  length            return maxArr

User · Answer

function mode arr     return arr reduce function counts key       var curCount    counts key        0    1      counts key       curCount      if  curCount  gt  counts max    counts max   curCount  counts mode   key        return counts        max 0  mode  null   mode

User · Answer

Here is my solution to this problem but with numbers and using the new  Set  feature  Its not very performant but i definitely had a lot of fun writing this and it does support multiple maximum values   const mode    arr    gt      new Set arr      map  value    gt   value  arr filter  v    gt  v     value  length      sort  a b    gt  a 1 -b 1      reverse      filter  value  i  a    gt  a indexOf value      i     filter  v  i  a    gt  v 1      a 0  1      map  v    gt  v 0    mode  1 2 3 3       3  mode  1 1 1 1 2 2 2 2 3 3 3       1 2    By the way do not use this for production this is just an illustration of how you can solve it with ES6 and Array functions only

User · Answer

For the sake of really easy to read  maintainable code I share this   function getMaxOcurrences arr           let item   arr 0     let ocurrencesMap          for  let i in arr        const current   arr i        if  ocurrencesMap current   ocurrencesMap current         else ocurrencesMap current    1       if  ocurrencesMap item   lt  ocurrencesMap current   item   current         return        item  item       ocurrences  ocurrencesMap item           Hope it helps someone

User · Answer

There are a lot of answers already but just want to share with you what I came up with    Can t say this solution counts on any edge case but anyway    const getMostFrequentElement     arr     gt      const counterSymbolKey    counter    const mostFrequentSymbolKey    mostFrequentKey     const result   arr reduce    acc  cur     gt        acc  cur     acc  cur     acc  cur     1   1      if   acc  cur    gt  acc  Symbol for  counterSymbolKey               acc  Symbol for  mostFrequentSymbolKey       cur       acc  Symbol for  counterSymbolKey       acc  cur              return acc              Symbol for  mostFrequentSymbolKey      null        Symbol for  counterSymbolKey      0          return result  Symbol for  mostFrequentSymbolKey         Hope it will be helpful for someone

User · Answer

This solution has O n  complexity function findhighestOccurenceAndNum a       let obj         let maxNum      let maxVal      for let v of a           obj v     obj v    1          if maxVal     undefined    obj v  gt  maxVal               maxNum  v              maxVal obj v                       console log maxNum    has max value      maxVal

User · Answer

a   pear    apple    orange    apple    b     max     maxi 0  for let k of a      if b k   b k     else b k  1    if maxi  lt  b k     max k  maxi b k

User · Answer

As I m using this function as a quiz for the interviewers  I post my solution   const highest   arr   gt   arr        reduce    acc  el     gt      acc k el    acc k el    acc k el    1   1   acc max   acc max   acc max  lt  acc k el    el   acc max   el   return acc        k       max  const test    0 1 2 3 4 2 3 1 0 3 2 2 2 3 3 2  console log highest test

User · Answer

function mode      var input      input   val   split         var mode         var m         var p           for var x   0 x lt  input length x           if m indexOf input x    -1           m m length  input x            for var x   0  x lt  m length x         p x  0      for var y   0  y lt input length y           if input y   m x          p x            for var x   0 x lt  p length x        if p x     Math max apply null  p          mode push m x             output   text mode

User · Answer

Trying out a declarative approach here  This solution builds an object to tally up the occurrences of each word  Then filters the object down to an array by comparing the total occurrences of each word to the highest value found in the object   const arr     hello    world    hello    again     const tally    acc  x    gt        if    acc x          acc x    1      return acc          acc x     1    return acc      const totals   arr reduce tally        const keys   Object keys totals    const values   keys map x   gt  totals x     const results   keys filter x   gt  totals x      Math max    values

User · Answer

With ES6  you can chain the method like this    x000D   x000D      function findMostFrequent arr    x000D        return arr x000D           reduce  acc  cur  ind  arr    gt    x000D            if  arr indexOf cur      ind    x000D              return     acc   cur  1    x000D              else   x000D              acc acc indexOf acc find e   gt  e 0      cur        x000D                cur  x000D                acc acc indexOf acc find e   gt  e 0      cur    1    1 x000D                 x000D              return acc  x000D              x000D                 x000D           sort  a  b    gt  b 1  - a 1   x000D           filter  cur  ind  arr    gt  cur 1      arr 0  1   x000D           map cur   gt  cur 0    x000D        x000D       x000D      console log findMostFrequent   pear    apple    orange    apple      x000D      console log findMostFrequent   pear    apple    orange    apple    pear      x000D   x000D   x000D    If two elements have the same occurrence  it will return both of them  And it works with any type of element

User · Answer

Based on Emissary s ES6  answer  you could use Array prototype reduce to do your comparison  as opposed to sorting  popping and potentially mutating your array   which I think looks quite slick   const mode    myArray    gt    myArray reduce       a b i arr   gt        arr filter v  gt v   a  length gt  arr filter v  gt v   b  length a b       null    I m defaulting to null  which won t always give you a truthful response if null is a possible option you re filtering for  maybe that could be an optional second argument  The downside  as with various other solutions  is that it doesn t handle  draw states   but this could still be achieved with a slightly more involved reduce function

User · Answer

var array    1  3  6  6  6  6  7  7  12  12  17       c          counters     s          sortable array  for  var i 0  i lt array length  i          c array i     c array i      0     initialize     c array i           count occurrences  for  var key in c        s push  key  c key         build sortable array from counters  s sort function a  b   return b 1 -a 1       var firstMode   s 0  0   console log firstMode

[javascript] Get the element with the highest occurrence in an array

Examples related to javascript

Examples related to mode