Question

关于如何在阵列中获取模式，我有一段时间了。数组中相同的元素将组合在一起。对于前者[Alex，Steven，Georg，Alice，Alex，Georg]; 回归将是：Alex：2，Steven：1，Georg：2，Alice：1;

我编写了代码，但它仅适用于1到10之间的数字。并且肯定有更好的方法。

（我认为你不需要我的代码，但无论如何都会粘贴它。）

var mode = function (data){
            var result1 = data.filter(function (verde) {return verde === 1});
            var result2 = data.filter(function (verde) {return verde === 2});
            var result3 = data.filter(function (verde) {return verde === 3});
            var result4 = data.filter(function (verde) {return verde === 4});
            var result5 = data.filter(function (verde) {return verde === 5});
            var result6 = data.filter(function (verde) {return verde === 6});
            var result7 = data.filter(function (verde) {return verde === 7});
            var result8 = data.filter(function (verde) {return verde === 8});
            var result9 = data.filter(function (verde) {return verde === 9});

            var nyadata = [result1.length, result2.length,
                           result3.length, result4.length,
                           result5.length, result6.length,
                           result7.length, result8.length,
                           result9.length];

            var nyarreymax = Math.max.apply(Math, nyadata);

            if (nyarreymax === result1.length){return 1;}
            if (nyarreymax === result2.length){return 2;}
            if (nyarreymax === result3.length){return 3;}
            if (nyarreymax === result4.length){return 4;}
            if (nyarreymax === result5.length){return 5;}
            if (nyarreymax === result6.length){return 6;}
            if (nyarreymax === result7.length){return 7;}
            if (nyarreymax === result8.length){return 8;}
            if (nyarreymax === result9.length){return 9;} 
            else { return  false;}

希望您能帮助我了解通常用于字符串和所有整数的代码。

Answer 1

我自己是js的初学者，不久前正在寻找同样的解决方案。以下是我发现的应该是您正在寻找的内容：

function findMode(arr) {
    var map = {};
    for (var i = 0; i < arr.length; i++) {
        if (map[arr[i]] === undefined) {
            map[arr[i]] = 0;
        }
        map[arr[i]] += 1;
    }
    var greatestFreq = 0;
    var mode;
    for (var prop in map) {
        if (map[prop] > greatestFreq) {
            greatestFreq = map[prop];
            mode = prop;
        }
    }
    return mode;
}

Answer 2

您可以使用checkbox尝试此操作，请参阅显示带计数值的控制台。

演示http://jsfiddle.net/ak69f/

for (int m = 0; m < tb_doublon.getRowCount(); m++) {
    Statement statdouble=null;  
    ResultSet rsdouble=null;

    //I get the value of the cell of the column 1 :id, line : i
    String id = (String)tb_doublon.getValueAt(m, 1);
    String cli = (String)tb_doublon.getValueAt(m, 2);

    //i browse the other table to enable or gray out the lines existing in that table with th id
    String doubleexistant ="select * from doublon where id='"+id+"' and cli='"+cli+"'" ;
    statdouble = conn.createStatement();
    rsdouble  = statdouble.executeQuery(doubleexistant);
    while (rsdouble.next()) {
      //i think this is here that i must enable or gray out the lines but i don't know how !!!!<br>             
    }
}

Answer 3

这是一个简单的递归解决方案，这似乎是四个答案中最快的解决方案，如您所见：http://jsperf.com/array-mode。

＆＃13;

var a = ["Alex", "Steven", "Georg", "Alice", "Alex", "Georg"];

function getMode(a, result) {
  result = result || {};
  
  if (a.length === 0)
    return result;
  
  var head = a.shift();
  if (result[head])
    result[head]++;
  else
    result[head] = 1;
  
  return getMode(a, result);
}

console.log(getMode(a));

＆＃13;

<script src="http://gh-canon.github.io/stack-snippet-console/console.min.js"></script>

＆＃13;

Answer 4

首先，定义一个包含结果的新数组。迭代你的名字数组。在每个循环内部，遍历结果数组。如果names数组中的当前名称存在于results数组中，请更改该值。

例如，如果您的names数组位于第二个“Alex”上，并且您遍历结果数组并发现“Alex：1”已经存在，请将值更改为“Alex：2”（您必须为此做一点字符串解析）。

如果名称不存在，请将其添加到“：1”

的末尾

然后，如果要返回模式，则必须编写另一个查找最大值的循环。有一个变量可以跟踪具有最大数字的名称的数组位置（假设它叫做maxIndex）。对于数组中的每个项目，将其与maxIndex处的数组值进行比较。如果它更高，请将maxIndex重置为当前索引。如果它等于或小于，则移动到数组的下一个项目。

我知道这非常罗嗦，所以如果您有任何问题，请告诉我。

Answer 5

另一种方法是创建一个接收数组的函数，将每个唯一的数组值分配给一个对象属性，如果它已经存在，则将对象属性值增加一，如下所示;

function countArray(array){
        var results = {};

        for(var x = 0; x < array.length; x++){

            if(results[array[x]] == undefined){
                results[array[x]] = 1;
            }else{
                results[array[x]] += 1;
            }
        }

        return results;
    }

    var checkArray = countArray(['alex', 'george', 'steve', 'alex']);

    console.log(checkArray); 
    // outputs "Object {alex: 2, george: 1, steve: 1}"

然后，您可以根据需要通过调用

来访问结果

console.log(checkArray.alex); // outputs 2

Answer 6

var numbers = [1,2,2,3,4,5];
var counts = numbers.reduce((counts, e) => { counts[e] = counts[e] ? counts[e] + 1 : 1; return counts; }, {});
var mode = Object.keys(counts).reduce((a, b) => (counts[a] > counts[b] ? a : b ));
console.log(mode);

Reduce函数可以在聚合中提供很大帮助。

Answer 7

我发现的方式与接受的答案非常相似，但是我想我会补充说，如果没有项目重复，或者没有单个项目重复最多，则没有模式，所以我的函数会检查并返回 null 如果是案例。

function calcMode(data) {
  let counts = {};
  data.forEach((d) => {
    if (counts[d] === undefined) {
      counts[d] = 0;
    }
    counts[d] += 1;
  });
  let mode,
    max = 0,
    repeats = 0;
  Object.keys(counts).forEach((k) => {
    if (counts[k] > max) {
      max = counts[k];
      mode = k;
      repeats = 0;
    } else if (counts[k] == max) repeats += 1;
  });
  if (!repeats) {
    if (isNaN(mode)) return mode;
    else return +mode;
  } else return null;
}

Answer 8

这是我的方法，我尝试了使用 reduce 的“函数式”风格。它还支持多模式，因此它将返回一组模式。

export function mode(vector) {
if (vector.length === 0) return undefined

 return (vector.reduce((accu, curr) => {
    const freqsMap = accu.freqsMap
    freqsMap.set(curr, (freqsMap.get(curr) || 0) + 1)

    const maxCount = freqsMap.get(curr) > accu.maxCount
        ? freqsMap.get(curr)
        : accu.maxCount
    const modes = freqsMap.get(curr) === accu.maxCount
        ? [...accu.modes, curr]
        : freqsMap.get(curr) > accu.maxCount
            ? [curr]
            : accu.modes

    return { freqsMap, maxCount, modes }
 }, { freqsMap: new Map(), maxCount: 1, modes: []})).modes
}

如何在数组中获取模式

8 个答案: