用单因素或多因素求解算法抛硬币？ [关闭]

Question

是使用抛硬币来生成从 1 到 9 的随机整数，使用单因素求解算法更快，还是使用多因素求解算法计算更快？

使用一次因式分解求解，将处理具有四个 f(2) 实例的求解尝试，对于四位/进程返回，其函数范围为 2^4=16。对于根据该方法使用 f(2) 生成从 1 到 9 的 int，16 个结果中有 9 个是有效的，并且每次求解尝试的 7 个可能返回将是求解尝试失败/重试。因此，这种从 1 到 9 生成 rand 整数的单因式分解方法具有 7/16=%44 的四进程函数求解尝试失败/重试率。

在算法上使用多个因素，相对而言，求解尝试失败/重试率可能会降低？

首先，f(2) 的两个实例可以生成一个从 1 到 4 的随机整数，只接受从 1 到 3 的返回值，对于两个进程求解尝试函数，求解尝试失败/重试率为 %25。

接下来，f(2) 的另外两个实例可以生成另一个从 1 到 4 的随机整数，只接受从 1 到 3 的返回，另外 %25 的两个进程求解尝试函数的求解尝试失败/重试率。

从 1 到 3 的第一个 rand int 可以添加到 {3* ((the second rand int from 1 to 3 result)-1)} 以产生一个从 1 到 9 的 rand int，它有 %25 失败/retry rate 用于解决其前两个进程的尝试，然后是 %25 的失败/重试率用于解决其后两个进程的尝试。

第二种算法的f(2) -> f(9)求解效率可能更高，因为它使用了多个因子，而不是单个因子？

有关通过抛硬币创建随机数生成器的讨论，请参阅Creating a random number generator from a coin toss

Answer 1

平均而言，“多因素”方法肯定需要更少的随机位。

我将在下面给出一个完整的计算，但要直观地了解原因，请考虑以下几点：

• 在单因素方法中，每组四个位有 9/16 的机会给出有效结果；如果失败，您必须重新开始。
• 在双因素方法中，每组四个位（= 两对两个位）有 9/16 的机会给出完整的有效结果（= 两个有效因素）；但即使它失败了，它也有可能至少取得了一些进展，以后可以重复使用。

所以从某种意义上说，双因素方法有两条“成功之路”：

• 一组成功的四位。
• 四个位的半成功集，然后是另一个半成功集。

而单因​​素方法只有第一条路径。

---

现在，进行一些数学运算。 . .

当一个给定的 Trial 有成功的概率 p，并且所有的 Trial 都是独立的，那么直到一次成功的预期 Trial 次数是 1/p。

此外，如果直到 one 成功之前的预期试验次数是 N，那么直到 m 成功之前的预期试验次数是 mN.

因此：

• 当您的试验是“获得四个随机位”并且您对成功的定义是“结果在 1 到 9 之间”时，您可以预期需要 16/9 次试验，这意味着 4·16/9 = 64/9 ≈ 7.11 随机位，在您得到结果之前。
• 当您的试验是“获得两个随机位”时，您对成功的定义是“结果在 1 和 3 之间”，并且您需要成功两次，那么您可以预期需要 2 ·4/3 = 8/3 次试验，意味着 2·8/3 = 16/3 ≈ 5.33 个随机位，然后才能得到结果。

---

下面是一些可运行的 JavaScript，它尝试了这两种方法 10,000 次，并根据平均位数和试验次数对它们进行了比较。 （当然，因为它调用Math.random() 来获取每一位，所以它是“不现实的”，因为它要求一堆随机位然后丢弃其中的大部分。我仅将其作为数学概念证明，而不是实现这两种方法的实际示例代码。）

alert((function () {

var totalNumBitsEverGotten = 0;

function getBit() {
  ++totalNumBitsEverGotten;
  return Math.random() < 0.5 ? 0 : 1;
}

function getNBits(n) {
  var result = 0;
  for (var i = 0; i < n; ++i) {
    result = 2 * result + getBit();
  }
  return result;
}

function getIntInRange(min, max) {
  if (min != 0) {
    return getIntInRange(0, max - min) + min;
  }
  var numBitsNeeded = 0;
  for (var tmp = max; tmp > 0; tmp >>= 1) {
    ++numBitsNeeded;
  }
  while (true) {
    var nBits = getNBits(numBitsNeeded);
    if (nBits <= max) {
      return nBits;
    }
  }
}

function countBitsToGet1To9_approach1() {
  var numBitsPreviouslyGotten = totalNumBitsEverGotten;
  getIntInRange(1, 9);
  return totalNumBitsEverGotten - numBitsPreviouslyGotten;
}

function countBitsToGet1To9_approach2() {
  var numBitsPreviouslyGotten = totalNumBitsEverGotten;
  getIntInRange(1, 3);
  getIntInRange(1, 3);
  return totalNumBitsEverGotten - numBitsPreviouslyGotten;
}

var NUM_TRIALS = 10000;

var approach1Sum = 0;
var approach2Sum = 0;

var approach1Wins = 0;
var approach2Wins = 0;

for (var i = 0; i < NUM_TRIALS; ++i) {
  var approach1 = countBitsToGet1To9_approach1();
  var approach2 = countBitsToGet1To9_approach2();

  approach1Sum += approach1;
  approach2Sum += approach2;

  if (approach1 < approach2) {
    ++approach1Wins;
  } else if (approach2 < approach1) {
    ++approach2Wins;
  }
}

return 'After ' + NUM_TRIALS + ' trials:\n' +
       '- Approach #1 average: ' + (approach1Sum / NUM_TRIALS) + ' bits.\n' +
       '- Approach #2 average: ' + (approach2Sum / NUM_TRIALS) + ' bits.\n' +
       '- Approach #1 was faster in ' + approach1Wins + ' trial(s).\n' +
       '- Approach #2 was faster in ' + approach2Wins + ' trial(s).\n' +
       '- The two approaches tied in ' + (NUM_TRIALS - approach1Wins - approach2Wins) + ' trial(s).\n';

})());