你需要的函数是rand1_7()，我写了rand1_5()，这样你就可以测试它并绘制它。

import numpy
def rand1_5():
    return numpy.random.randint(5)+1

def rand1_7():
    q = 0
    for i in xrange(7):  q+= rand1_5()
    return q%7 + 1

与Martin的答案相似，但却很少抛弃熵:

int rand7(void) {
  static int m = 1;
  static int r = 0;

  for (;;) {
    while (m <= INT_MAX / 5) {
      r = r + m * (rand5() - 1);
      m = m * 5;
    }
    int q = m / 7;
    if (r < q * 7) {
      int i = r % 7;
      r = r / 7;
      m = q;
      return i + 1;
    }
    r = r - q * 7;
    m = m - q * 7;
  }
}

在这里，我们在0到m-1之间建立一个随机值，并尝试通过添加尽可能多的状态来最大化m，而不会溢出(INT_MAX是C中适合int的最大值，或者您可以将其替换为任何在您的语言和体系结构中有意义的大值)。

然后;如果r落在能被7整除的最大可能区间内，那么它包含一个可行的结果，我们可以将这个区间除以7，取余数作为我们的结果，并将剩余的值返回到熵池。否则r在另一个不均匀的区间内我们就必须抛弃这个不拟合区间重新启动熵池。

与这里的流行答案相比，它调用rand5()的频率平均减少了一半。

为了提高性能，可以将除法分解为琐碎的比特旋转和lut。

PHP解决方案

<?php
function random_5(){
    return rand(1,5);
}


function random_7(){
 $total = 0;

    for($i=0;$i<7;$i++){
        $total += random_5();
    }

    return ($total%7)+1; 
}

echo random_7();
?>

Here's a solution that fits entirely within integers and is within about 4% of optimal (i.e. uses 1.26 random numbers in {0..4} for every one in {0..6}). The code's in Scala, but the math should be reasonably clear in any language: you take advantage of the fact that 7^9 + 7^8 is very close to 5^11. So you pick an 11 digit number in base 5, and then interpret it as a 9 digit number in base 7 if it's in range (giving 9 base 7 numbers), or as an 8 digit number if it's over the 9 digit number, etc.:

abstract class RNG {
  def apply(): Int
}

class Random5 extends RNG {
  val rng = new scala.util.Random
  var count = 0
  def apply() = { count += 1 ; rng.nextInt(5) }
}

class FiveSevener(five: RNG) {
  val sevens = new Array[Int](9)
  var nsevens = 0
  val to9 = 40353607;
  val to8 = 5764801;
  val to7 = 823543;
  def loadSevens(value: Int, count: Int) {
    nsevens = 0;
    var remaining = value;
    while (nsevens < count) {
      sevens(nsevens) = remaining % 7
      remaining /= 7
      nsevens += 1
    }
  }
  def loadSevens {
    var fivepow11 = 0;
    var i=0
    while (i<11) { i+=1 ; fivepow11 = five() + fivepow11*5 }
    if (fivepow11 < to9) { loadSevens(fivepow11 , 9) ; return }
    fivepow11 -= to9
    if (fivepow11 < to8) { loadSevens(fivepow11 , 8) ; return }
    fivepow11 -= to8
    if (fivepow11 < 3*to7) loadSevens(fivepow11 % to7 , 7)
    else loadSevens
  }
  def apply() = {
    if (nsevens==0) loadSevens
    nsevens -= 1
    sevens(nsevens)
  }
}

如果你将一个测试粘贴到解释器中(实际上是REPL)，你会得到:

scala> val five = new Random5
five: Random5 = Random5@e9c592

scala> val seven = new FiveSevener(five)
seven: FiveSevener = FiveSevener@143c423

scala> val counts = new Array[Int](7)
counts: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0)

scala> var i=0 ; while (i < 100000000) { counts( seven() ) += 1 ; i += 1 }
i: Int = 100000000

scala> counts
res0: Array[Int] = Array(14280662, 14293012, 14281286, 14284836, 14287188,
14289332, 14283684)

scala> five.count
res1: Int = 125902876

分布很好，很平坦(在每个箱子中，10^8的1/7大约在10k范围内，就像预期的近似高斯分布一样)。

为什么这行不通?除了对rand5()的额外调用之外?

i = rand5() + rand5() + (rand5() - 1) //Random number between 1 and 14

i = i % 7 + 1;

如果我们考虑尝试给出最有效答案的附加约束，即给定一个长度为m(1-5)的均匀分布整数的输入流I，输出一个长度为m(1-7)的均匀分布整数的流O，长度为L(m)。

最简单的分析方法是将流I和O分别视为5元数和7元数。这是通过主答案的思想来实现的，即取流a1, a2, a3，…- > a1 + a2 + 5 * 5 ^ 2 * a3 + . .流O也是如此。

然后如果我们取长度为m的输入流的一段，选n s.t, 5^m-7^n=c，其中c>0，且尽可能小。然后有一个从长度为m的输入流到1到5^m的整数的统一映射，还有一个从1到7^n的整数到长度为n的输出流的统一映射，当映射的整数超过7^n时，我们可能不得不从输入流中丢失一些情况。

这就给出了L(m)的值约为m (log5/log7)也就是。82米。

上述分析的难点是方程5^m-7^n=c，它不容易精确求解，而在1到5^m的均匀值超过7^n的情况下，我们失去了效率。

问题是如何接近m (log5/log7)的最佳可能值。例如，当这个数字接近一个整数时，我们能否找到一种方法来实现这个精确的整数值输出?

如果5^m-7^n=c，那么从输入流中，我们有效地生成了一个从0到(5^m)-1的均匀随机数，并且不使用任何高于7^n的值。但是，这些值可以被保存并再次使用。它们有效地生成了从1到5^m-7^n的统一数字序列。所以我们可以尝试使用这些，并将它们转换成7位数，这样我们就可以创建更多的输出值。

如果我们让T7(X)是由大小为X的均匀输入导出的随机(1-7)整数的输出序列的平均长度，并假设5^m=7^n0+7^n1+7^n2+…+ 7 ^ nr + s, s < 7。

那么T7(5^m)=n0x7^n0/5^m + ((5^m-7^n0)/5^m) T7(5^m-7^n0)因为我们有一个无长度序列，概率为7^n0/5^m，残差长度为5^m-7^n0，概率为(5^m-7^n0)/5^m)。

如果我们一直代入，我们得到:

T7(5^m) = n0x7^n0/5^m + n1x7^n1/5^m + ... + nrx7^nr/5^m  = (n0x7^n0 + n1x7^n1 + ... + nrx7^nr)/5^m

因此

L(m)=T7(5^m)=(n0x7^n0 + n1x7^n1 + ... + nrx7^nr)/(7^n0+7^n1+7^n2+...+7^nr+s)

另一种说法是:

If 5^m has 7-ary representation `a0+a1*7 + a2*7^2 + a3*7^3+...+ar*7^r
Then L(m) = (a1*7 + 2a2*7^2 + 3a3*7^3+...+rar*7^r)/(a0+a1*7 + a2*7^2 + a3*7^3+...+ar*7^r)

最好的情况是上面的原始情况，即5^m=7^n+s，其中s<7。

然后机械师》(5 ^ m) = nx (7 ^ n) / (7 ^ n + s) = o (n + 1) = m (Log5 / Log7) + o(1)美国之前。

最坏的情况是我们只能找到k和s.t 5^m = kx7+s。

Then T7(5^m) = 1x(k.7)/(k.7+s) = 1+o(1)

其他情况介于两者之间。看看对于很大的m，我们能做得多好，也就是说，我们能多好地得到误差项，这将是很有趣的:

T7(5^m) = m (Log5/Log7)+e(m)

一般来说，似乎不可能实现e(m)=o(1)但希望我们可以证明e(m)=o(m)。

整个问题取决于5^m的7位数字对不同m值的分布。

我相信有很多理论涵盖了这一点，我可能会在某个时候看一看并报告。