Question

我正在使用以下函数来获取数组中最常用的项目：

Array.prototype.array_most_frequent = function()  {
  var m=0, mf=0;
  for (var i=0; i<this.length; i++) {
          for (var j=i; j<this.length; j++)
          {
            if (this[i] == this[j]) m++;
            if (mf<m) {mf=m; item = this[i]; }
          }
          m=0;
  }
  return item;
}

工作正常 - 但如何获得数组中最稀有的项目？

例如，var array=[2,1,2,5,5]应返回“1”。

我的阵列中最不频繁的项目有一种简单的方法吗？

提前致谢。

Answer 1

使用Map创建Array#reduce次出现的ES6解决方案。然后展开地图以获取条目，并减少具有最小出现次数的条目的条目：

const array=[2,1,2,5,5];

const result = [...array.reduce((r, n) => // create a map of occurrences
    r.set(n, (r.get(n) || 0) + 1), new Map()
  )]
  .reduce((r, v) => v[1] < r[1] ? v : r)[0]; // get the the item that appear less times


console.log(result);

Answer 2

如果sort函数不使数组发生变异，甚至不通过函数传递参数，则简短的解决方案可能是这样。（如果传递给类构造函数，则不会发生。）

稍作修改... this。

const arr = [2, 1, 2, 5, 5];
const result = arr.sort((a,b) =>
          arr.filter(v => v===b).length
        - arr.filter(v => v===a).length
    ).pop();

console.log(result)

但是有时不希望有可变性，这可能会带来不便，因此请遵循以下没有可变性的解决方案：

基于this解决方案，该解决方案只为对象计数并添加重复值的名称以及重复值发生的次数。之后，只需取至少一个，然后按最小值搜索对象以返回重复最少的键的名称。

const arr = [2, 1, 2, 5, 5];
const reducedOnes = arr.reduce((acc, val) => ({...acc, [val]: (acc[val] || 0) + 1}), {});
const leastFrequency = Math.min(...Object.values(reducedOnes));
const leastItem = Object.keys(reducedOnes).find(el=>reducedOnes[el]===leastFrequency);

console.log(leastItem);

Answer 3

var arr = [2,1,2,5,5];
var frequencyMap = {};
for(var i=0; i<arr.length; i++) {
   frequencyMap[arr[i]] = frequencyMap[arr[i]] || 0;
   frequencyMap[arr[i]]++;
}
var maxValue = 0,maxFreq=0, minValue=NUMBER.MAX_INTEGER,minFreq=0;
for (var key in frequencyMap) {
    if (frequencyMap[key] > maxFreq){
       maxFreq  = frequencyMap[key];
       maxValue = key;
    }else if (frequencyMap[key] < minFreq){
       minFreq  = frequencyMap[key];
       minValue = key;
    }
}

Answer 4

您可以使用哈希来跟踪事件，然后返回其值的min值。

function leastFrequent(arr) {
    var dict = {};
    arr.forEach(function(el) {
        if (!dict[el]) dict[el] = 0;
        dict[el]++;
    });
    return Math.min.apply(null, Object.values(dict));
}

// ES6+
const leastFrequent = arr => {
    const dict = {};
    arr.forEach(function(el) {
        if (!dict[el]) dict[el] = 0;
        dict[el]++;
    });
    return Math.min(...Object.values(dict));
}

干杯

Answer 5

ES6-way没有未使用的迭代：

Document

Answer 6

您可以创建一个字典来计算数组元素的出现次数，然后返回最低计数的键。

＆＃13;

@"yandexmaps://maps.yandex.ru/?pt={0},{1}"

＆＃13;

Answer 7

const arr = [1, 1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 4]

function leastFrequent(items) {
  let leastFrequentNumber = items[0]
  const counted = items.reduce((acc, item) => { 
    if (!acc[item]) {
      acc[item] = 1
    } else {
      acc[item]++
    }

    if(acc[item] < acc[leastFrequentNumber]) {
      leastFrequentNumber = item
    }

    return acc;
  }, {});

  return leastFrequentNumber
}

console.log(leastFrequent(arr)) //3

如何获得最不频繁的数组项 - javascript？

7 个答案: