Question

我一直在努力寻找或找出算法。

任务：基本上，我有一系列的概率：

var input = [0.1, 0.2, 0.3, 0.1];

我们将这些输入的名称分别命名为：A，B，C和D。

我还有一个变量“ m”，它可以告诉我要获得结果需要发生多少这些事情。例如：

var m = 2;

这个变量m告诉我，如果这两个（或更多）概率中的任何一个发生，事件就会发生。

因此，在这种情况下，对于事件发生，所有可能的事件发生方式是：

ABCD 美国广播公司 ABD BCD AB 交流电广告公元前 BD和CD

现在我需要计算它们的概率，我已经有了计算AND和OR（输入只是一个概率数组）的算法。

AND：

if (input.length > 0) {
    output = 1;
}
for (i = 0; i < input.length; i++) {
    output = input[i] * output;
}

OR：

if (input.length > 0) {
    output = input[0];
}
for (i = 1; i < input.length; i++) {
    output = (output + input[i]) - (output * input[i]);
}

所以我正在努力弄清楚如何在所有可能的可能性之间循环...并具有类似的东西：（A和B以及C和D）或（A和B和C）或（A和B和D）……等等……我希望您能理解。

Answer 1

通过使用生成所有可能组合的递归函数，您可以获得最少两个的所需数组组合。

function getC(array, min) {
    function iter(i, temp) {
        var t = temp.concat(array[i]);
        if (i === array.length) return;
        iter(i + 1, t);
        iter(i + 1, temp);
        if (t.length >= min) {
            result.push(t);
        }
    }
    
    var result = [];
    iter(0, []);
    return result;
}

var input = [0.1, 0.2, 0.3, 0.1];
console.log(getC(input, 2).map(a => a.join(' ')));

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

这是一个简单的非递归解决方案，用于枚举至少包含curl -i -X POST -u sensor1@DEFAULT_TENANT:hono-secret -H 'Content-Type: application/json' --data-binary '{"sensor1": 5}' http://hono.eclipse.org:8080/telemetry?hono-ttd=60个元素的所有组合。

由于JS位算术仅限于32位，因此仅适用于m <32。

Answer 3

您可以通过两个嵌套循环遍历2个元素（AB，CD等）的所有组合：

 for(let i = 0; i < input.length; i++) {
  for(let j = i + 1; j < input.length; j++) {
    // possible combination: i and j
    for(let k = j; k < input.length; k++) {  
     // possible combination: i, j, k
     // and so on
    }
  }
}

至少可以使用嵌套生成器将其生成索引数组（m）的[0, 1], [0, 2], [1, 2], [0, 1, 2]元素进行概括：

 function* combinations(length, m = 1, start = 0) {
   // Base Case: If there is only one index left, yield that:
   if(start === length - 1) {
     yield [length - 1];
    return;
   }

   // Otherwise go over all left indices
   for(let i = start; i < length; i++) {
     // And get all further combinations, for 0 that will be [1, 2], [1] and [2]
     for(const nested of combinations(length, m - 1, i + 1)) {
      // Yield the nested path, e.g. [0, 1], [0, 1, 2] and [0, 2]
      yield [i, ...nested];
     }
     // If the minimum length is already reached yield the index itself
     if(m <= 1) yield [i];
  }
}

现在，对于每种组合，我们只需要将概率相乘并相加即可：

 let result = 0;

 for(const combination of combimations(input.length, m))
   result += combination.reduce((prev, i) => prev * input[i], 1);

灵活的算法来计算所有可能方案的可能性

3 个答案: