Get the element with the highest occurrence in an array

这只是模式。这是一个 快速，未经优化解决方案。它应该是 O (n)。

function mode(array)
{
if(array.length == 0)
return null;
var modeMap = {};
var maxEl = array[0], maxCount = 1;
for(var i = 0; i < array.length; i++)
{
var el = array[i];
if(modeMap[el] == null)
modeMap[el] = 1;
else
modeMap[el]++;
if(modeMap[el] > maxCount)
{
maxEl = el;
maxCount = modeMap[el];
}
}
return maxEl;
}

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 < b[k]) { max=k; maxi=b[k] }
}

var mode = 0;
var c = 0;
var num = new Array();
var value = 0;
var greatest = 0;
var ct = 0;

注意: ct 是数组的长度。

function getMode()
{
for (var i = 0; i < ct; i++)
{
value = num[i];
if (i != ct)
{
while (value == num[i + 1])
{
c = c + 1;
i = i + 1;
}
}
if (c > greatest)
{
greatest = c;
mode = value;
}
c = 0;
}
}

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 < array.length; i++) {
var el = array[i];


if (modeMap[el] == null) modeMap[el] = 1;
else modeMap[el]++;


if (modeMap[el] > maxCount) {
maxEl = el;
maxCount = modeMap[el];
} else if (modeMap[el] == maxCount) {
maxEl += "&" + el;
maxCount = modeMap[el];
}
}
return maxEl;
}

This will now return a string with the mode element(s) delimited by a & symbol. When the result is received it can be split on that & element and you have your mode(s).

另一种选择是返回一个由模式元素组成的数组，如下所示:

function modeArray(array) {
if (array.length == 0) return null;
var modeMap = {},
maxCount = 1,
modes = [];


for (var i = 0; i < array.length; i++) {
var el = array[i];


if (modeMap[el] == null) modeMap[el] = 1;
else modeMap[el]++;


if (modeMap[el] > maxCount) {
modes = [el];
maxCount = modeMap[el];
} else if (modeMap[el] == maxCount) {
modes.push(el);
maxCount = modeMap[el];
}
}
return modes;
}

在上面的例子中，您可以将函数的结果作为一个模式数组来处理。

我想你有两种方法，两种都有优势。

然后排序计数或循环通过，并使用一个哈希表来为您进行计数。

散列表非常好，因为一旦完成了处理，就拥有了所有不同的元素。但是，如果有数百万个条目，那么如果复制率很低，散列表最终可能会占用大量内存。然后执行排序和计数的方法将具有更可控的内存占用。

是时候采取另一种解决方案了:

function getMaxOccurrence(arr) {
var o = {}, maxCount = 0, maxValue, m;
for (var i=0, iLen=arr.length; i<iLen; i++) {
m = arr[i];


if (!o.hasOwnProperty(m)) {
o[m] = 0;
}
++o[m];


if (o[m] > 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<iL; i++) {
m = a[i];
o.hasOwnProperty(m)? ++o[m] : o[m] = 1;
if (o[m] > mC) mC = o[m], mV = m;
}
return mV;
}

如果要避免不存在的成员(例如稀疏数组) ，则需要额外的 hasOwnProperty测试:

function getMaxOccurrence(a) {
var o = {}, mC = 0, mV, m;
for (var i=0, iL=a.length; i<iL; i++) {
if (a.hasOwnProperty(i)) {
m = a[i];
o.hasOwnProperty(m)? ++o[m] : o[m] = 1;
if (o[m] > mC) mC = o[m], mV = m;
}
}
return mV;
}


getMaxOccurrence([,,,,,1,1]); // 1

这里的其他答案将返回 未定义。

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 “优雅” code (as stipulated by the OP) favours readability - which is of course subjective...

function mode(arr){
return arr.sort((a,b) =>
arr.filter(v => v===a).length
- arr.filter(v => v===b).length
).pop();
}


mode(['pear', 'apple', 'orange', 'apple']); // apple

在这个特殊的例子中，如果集合中的两个或多个元素具有相同的匹配项，那么将返回数组中最新出现的元素。同样值得指出的是，它将修改您的原始数组——如果您希望预先使用 Array.slice调用，则可以防止这种修改。

Edit: updated the example with some ES6 肥箭 because 二零一五年 happened and I think they look pretty... If you are concerned with backwards compatibility you can find this in the 修订历史.

var array = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17],
c = {}, // counters
s = []; // sortable array


for (var i=0; i<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);

这个解决方案可以返回一个数组的多个元素，例如，一个数组

arr = [ 3, 4, 3, 6, 4, ];

有两个模式值: 3和 6。

这就是解决办法。

function find_mode(arr) {
var max = 0;
var maxarr = [];
var counter = [];
var maxarr = [];


arr.forEach(function(){
counter.push(0);
});


for(var i = 0;i<arr.length;i++){
for(var j=0;j<arr.length;j++){
if(arr[i]==arr[j])counter[i]++;
}
}




max=this.arrayMax(counter);
  

for(var i = 0;i<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] > max) {
max = arr[len];
}
}
return max;
};


function onlyUnique(value, index, self) {
return self.indexOf(value) === index;
}

function mode(arr){
return arr.reduce(function(counts,key){
var curCount = (counts[key+''] || 0) + 1;
counts[key+''] = curCount;
if (curCount > counts.max) { counts.max = curCount; counts.mode = key; }
return counts;
}, {max:0, mode: null}).mode
}

你可以试试这个:

 // 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 < l; i ++) {
if (a.indexOf(us[i]) === -1) {
continue;
} else if (a.indexOf(us[i]) != -1 && a.length > 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 < l; i ++) {
r[uelms[i]] = s.match(new RegExp(uelms[i], 'g')).length;
}


m = uelms[0];
for (var p in r) {
if (r[p] > r[m]) {
m = p;
} else {
continue;
}
}


return m;
}

你可以用 O (n)复杂度来解它

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 < 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] > max)
{
max = obj[obIndex];
index = obIndex;
}
}
console.log(index+" got maximum time repeated, with "+ max +" times" );

只需复制和粘贴在铬控制台运行以上代码。

这个函数是每种类型信息的通用函数。它计算元素的出现次数，然后返回具有最大出现次数的数组。

function mode () {
var arr = [].slice.call(arguments);
if ((args.length == 1) && (typeof args[0] === "object")) {
args = args[0].mode();
}


var obj = {};
for(var i = 0; i < 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] > max) max = obj[w];
}


ret_val = [];
for (w in obj) {
if (obj[w] == max) ret_val.push(w);
}


return ret_val;
}

在这里尝试一种声明式的方法。此解决方案构建一个对象来计算每个单词的出现次数。然后通过比较每个单词的总出现次数和对象中找到的最高值，将对象过滤到一个数组中。

const arr = ['hello', 'world', 'hello', 'again'];


const tally = (acc, x) => {


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 => totals[x]);


const results = keys.filter(x => totals[x] === Math.max(...values));

下面是我对这个问题的解决方案，但使用数字和新的“设置”功能。它的性能不是很好，但我肯定有很多乐趣写这一点，它确实支持多个最大值。

const mode = (arr) => [...new Set(arr)]
.map((value) => [value, arr.filter((v) => v === value).length])
.sort((a,b) => a[1]-b[1])
.reverse()
.filter((value, i, a) => a.indexOf(value) === i)
.filter((v, i, a) => v[1] === a[0][1])
.map((v) => v[0])


mode([1,2,3,3]) // [3]
mode([1,1,1,1,2,2,2,2,3,3,3]) // [1,2]

顺便说一下，不要在生产中使用这个函数，这只是一个例子，说明如何只使用 ES6和 Array 函数来解决这个问题。

const mode = (str) => {
return str
.split(' ')
.reduce((data, key) => {
let counter = data.map[key] + 1 || 1
data.map[key] = counter


if (counter > 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'))

基于 特使的 ES6 + 答案，您可以使用 Array.prototype.reduce进行比较(而不是排序、弹出和潜在的数组变异) ，我认为这看起来相当顺利。

const mode = (myArray) =>
myArray.reduce(
(a,b,i,arr)=>
(arr.filter(v=>v===a).length>=arr.filter(v=>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

与其他各种解决方案一样，它的缺点是不能处理“绘制状态”，但是通过稍微复杂一些的 reduce 函数仍然可以实现这一点。

我的解决办法是:-

function frequent(number){
var count = 0;
var sortedNumber = number.sort();
var start = number[0], item;
for(var i = 0 ;  i < sortedNumber.length; i++){
if(start === sortedNumber[i] || sortedNumber[i] === sortedNumber[i+1]){
item = sortedNumber[i]
}
}
return item
  

}


console.log( frequent(['pear', 'apple', 'orange', 'apple']))

function mode(){
var input = $("input").val().split(",");
var mode = [];
var m = [];
var p = [];
for(var x = 0;x< input.length;x++){
if(m.indexOf(input[x])==-1){
m[m.length]=input[x];
}}
for(var x = 0; x< m.length;x++){
p[x]=0;
for(var y = 0; y<input.length;y++){
if(input[y]==m[x]){
p[x]++;
}}}
for(var x = 0;x< p.length;x++){
if(p[x] ==(Math.max.apply(null, p))){
mode.push(m[x]);
}}
$("#output").text(mode);}

function mode(array){
var set = Array.from(new Set(array));
var counts = set.map(a=>array.filter(b=>b==a).length);
var indices = counts.map((a,b)=>Math.max(...counts)===a?b:0).filter(b=>b!==0);
var mode = indices.map(a=>set[a]);
return mode;
}

Try it too, this does not take in account browser version.

function mode(arr){
var a = [],b = 0,occurrence;
for(var i = 0; i < arr.length;i++){
if(a[arr[i]] != undefined){
a[arr[i]]++;
}else{
a[arr[i]] = 1;
}
}
for(var key in a){
if(a[key] > b){
b = a[key];
occurrence = key;
}
}
return occurrence;
}
alert(mode(['segunda','terça','terca','segunda','terça','segunda']));

请注意，此函数返回数组中的最新出现次数 当两个或更多的条目出现相同的次数！

As I'm using this function as a quiz for the interviewers, I post my solution:

const highest = arr => (arr || []).reduce( ( acc, el ) => {
acc.k[el] = acc.k[el] ? acc.k[el] + 1 : 1
acc.max = acc.max ? acc.max < 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))

Here is my way. I try to group data fist.

const _ = require("underscore")


var test  = [ 1, 1, 2, 1 ];
var groupResult = _.groupBy(test, (e)=> e);

GroupResult 应该是

{
1: [1, 1, 1]
2: [2]
}

然后找到具有最长数组的属性

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

完整的代码看起来像

const _ = require("underscore")


var test  = [ 1, 1, 2, 1 ];
var groupResult= _.groupBy(test, (e)=> 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 < 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;
}

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 < len; i++){
var word = array[i];


if(counts[word] === undefined){
counts[word] = 1;
}else{
counts[word] = counts[word] + 1;
}
if(counts[word] > compare){
compare = counts[word];
mostFrequent = cats[i];
}
}
return mostFrequent;
})(cats);

With ES6, you can chain the method like this:

    function findMostFrequent(arr) {
return arr
.reduce((acc, cur, ind, arr) => {
if (arr.indexOf(cur) === ind) {
return [...acc, [cur, 1]];
} else {
acc[acc.indexOf(acc.find(e => e[0] === cur))] = [
cur,
acc[acc.indexOf(acc.find(e => e[0] === cur))][1] + 1
];
return acc;
}
}, [])
.sort((a, b) => b[1] - a[1])
.filter((cur, ind, arr) => cur[1] === arr[0][1])
.map(cur => cur[0]);
}
    

console.log(findMostFrequent(['pear', 'apple', 'orange', 'apple']));
console.log(findMostFrequent(['pear', 'apple', 'orange', 'apple', 'pear']));

如果两个元素具有相同的匹配项，它将返回它们。它适用于任何类型的元素。

// O(n)
var arr = [1, 2, 3, 2, 3, 3, 5, 6];
var duplicates = {};
max = '';
maxi = 0;
arr.forEach((el) => {
duplicates[el] = duplicates[el] + 1 || 1;
if (maxi < duplicates[el]) {
max = el;
maxi = duplicates[el];
}
});
console.log(max);

下面是使用内置映射的现代版本(所以它不仅仅适用于可以转换为唯一字符串的内容) :

'use strict';


const histogram = iterable => {
const result = new Map();


for (const x of iterable) {
result.set(x, (result.get(x) || 0) + 1);
}


return result;
};


const mostCommon = iterable => {
let maxCount = 0;
let maxKey;


for (const [key, count] of histogram(iterable)) {
if (count > maxCount) {
maxCount = count;
maxKey = key;
}
}


return maxKey;
};


console.log(mostCommon(['pear', 'apple', 'orange', 'apple']));

另一个 JS 解决方案来自: https://www.w3resource.com/javascript-exercises/javascript-array-exercise-8.php

也可以试试这个:

let arr =['pear', 'apple', 'orange', 'apple'];


function findMostFrequent(arr) {
let mf = 1;
let m = 0;
let item;


for (let i = 0; i < arr.length; i++) {
for (let j = i; j < arr.length; j++) {
if (arr[i] == arr[j]) {
m++;
if (m > mf) {
mf = m;
item = arr[i];
}
}
}
m = 0;
}


return item;
}


findMostFrequent(arr); // apple

下面是 ES6处理 O (n)复杂性的另一种方法

const result = Object.entries(
['pear', 'apple', 'orange', 'apple'].reduce((previous, current) => {
if (previous[current] === undefined) previous[current] = 1;
else previous[current]++;
return previous;
}, {})).reduce((previous, current) => (current[1] >= previous[1] ? current : previous))[0];
console.log("Max value : " + result);

为了便于阅读和维护，我分享以下代码:

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] < ocurrencesMap[current]) item = current;
}


return {
item: item,
ocurrences: ocurrencesMap[item]
};
}

Hope it helps someone ;)!

可以试试:

var arr = [10,3,4,5,3,4,3,8,3,6,3,5,1];
var temp = {};


for(let i=0;i<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]>max){
max = temp[i];
maxEle=i;
}
}


console.log(`most occurred element is ${maxEle} and number of times is ${max}`);`

已经有很多答案了，只是想和你分享一下我的想法:) 不能说这个解决方案依赖于任何边界情况，但无论如何)

const getMostFrequentElement = ( arr ) => {
const counterSymbolKey = 'counter'
const mostFrequentSymbolKey = 'mostFrequentKey'


const result = arr.reduce( ( acc, cur ) => {
acc[ cur ] = acc[ cur ] ? acc[ cur ] + 1 : 1


if ( acc[ cur ] > 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 )

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 => el.someUniqueProp)), arr => arr.length)[0];

这是字符串:

const mostFrequent = _.maxBy(Object.values(_.groupBy(inputArr, el => el)), arr => arr.length)[0];

只是将数据按照一定的标准进行分组，然后找到最大的组。

Here is my way to do it so just using .filter.

var arr = ['pear', 'apple', 'orange', 'apple'];


function dup(arrr) {
let max = { item: 0, count: 0 };
for (let i = 0; i < arrr.length; i++) {
let arrOccurences = arrr.filter(item => { return item === arrr[i] }).length;
if (arrOccurences > max.count) {
max = { item: arrr[i], count: arrr.filter(item => { return item === arrr[i] }).length };
}
}
return max.item;
}
console.log(dup(arr));

该解具有 O (n)复杂度

function findhighestOccurenceAndNum(a){
let obj={};
let maxNum;
let maxVal;
for(let v of a){
obj[v]= ++obj[v] ||1;
if(maxVal === undefined || obj[v]> maxVal){
maxNum= v;
maxVal=obj[v];
}
}
console.log(maxNum + 'has max value = ', maxVal);
}

简单的解决办法！

function mostFrequentElement(arr) {
let res = [];
for (let x of arr) {
let count = 0;
for (let i of arr) {
if (i == x) {
count++;
}
}
res.push(count);
}
return arr[res.indexOf(Math.max(...res))];
}
array = [13 , 2 , 1 , 2 , 10 , 2 , 1 , 1 , 2 , 2];
let frequentElement = mostFrequentElement(array);
console.log(`The frequent element in ${array} is ${frequentElement}`);

循环所有元素并收集数组中每个元素的 Count，这是解决方案的思想

我的解决办法是:-

 const arr = [
2, 1, 10, 7, 10, 3, 10, 8, 7, 3, 10, 5, 4, 6, 7, 9, 2, 2, 2, 6, 3, 7, 6, 9, 8,
9, 10, 8, 8, 8, 4, 1, 9, 3, 4, 5, 8, 1, 9, 3, 2, 8, 1, 9, 6, 3, 9, 2, 3, 5, 3,
2, 7, 2, 5, 4, 5, 5, 8, 4, 6, 3, 9, 2, 3, 3, 10, 3, 3, 1, 4, 5, 4, 1, 5, 9, 6,
2, 3, 10, 9, 4, 3, 4, 5, 7, 2, 7, 2, 9, 8, 1, 8, 3, 3, 3, 3, 1, 1, 3,
];


function max(arr) {
let newObj = {};


arr.forEach((d, i) => {
if (newObj[d] != undefined) {
++newObj[d];
} else {
newObj[d] = 0;
}
});
let nwres = {};
for (let maxItem in newObj) {
if (newObj[maxItem] == Math.max(...Object.values(newObj))) {
nwres[maxItem] = newObj[maxItem];
}
}
return nwres;
}




console.log(max(arr));

function getData(arr){
let obj = {}
let maxElementCount = 0
let maxEle = ''
for(let i = 0 ;i<arr.length;i++){
if(!obj[arr[i]]){
obj[arr[i]] = 1
}else{
obj[arr[i]] += 1
if(maxElementCount < obj[arr[i]]){
maxElementCount = obj[arr[i]]
maxEle = arr[i]
}
}
}
console.log(maxElementCount, maxEle)
return obj
}

您可以使用这个简单的方法来获得元素的最大计数

    const frequence = (array) =>
array.reduce(
(acc, item) =>
array.filter((v) => v === acc).length >=
array.filter((v) => v === item).length
? acc
: item,
null
);

frequence([1, 1, 2])