package CareerCup;

public class RangeTransform {
 static int counter = (int)(Math.random() * 5 + 1);

 private int func() {
  return (int) (Math.random() * 5 + 1);
 }

 private int getMultiplier() {
  return counter % 5 + 1;
 }

 public int rangeTransform() {
  counter++;
  int count = getMultiplier();
  int mult = func() + 5 * count;
  System.out.println("Mult is : " + 5 * count);
  return (mult) % 7 + 1;
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  RangeTransform rangeTransform = new RangeTransform();
  for (int i = 0; i < 35; i++)
   System.out.println("Val is : " + rangeTransform.rangeTransform());
 }
}

rand25() =5*(rand5()-1) + rand5()

rand7() { 
   while(true) {
       int r = rand25();
       if (r < 21) return r%3;         
   }
}

为什么这样做:循环永远运行的概率是0。

我玩了一下，我为这个Rand(7)算法写了“测试环境”。例如，如果你想尝试哪种分布给你的算法，或者需要多少次迭代才能生成所有不同的随机值(对于Rand(7) 1-7)，你可以使用它。

我的核心算法是:

return (Rand5() + Rand5()) % 7 + 1;

和亚当·罗森菲尔德的分布一样均匀。(我将其包含在代码片段中)

private static int Rand7WithRand5()
{
    //PUT YOU FAVOURITE ALGORITHM HERE//

    //1. Stackoverflow winner
    int i;
    do
    {
        i = 5 * (Rand5() - 1) + Rand5(); // i is now uniformly random between 1 and 25
    } while (i > 21);
    // i is now uniformly random between 1 and 21
    return i % 7 + 1;

    //My 2 cents
    //return (Rand5() + Rand5()) % 7 + 1;
}

这个“测试环境”可以采用任何Rand(n)算法并测试和评估它(分布和速度)。只需将代码放入“Rand7WithRand5”方法并运行代码片段。

一些观察:

亚当·罗森菲尔德(Adam Rosenfield)的算法并不比我的算法分布得更好。不管怎样，两种算法的分布都很糟糕。 本机Rand7(随机的。Next(1,8))完成，因为它在大约200+迭代中生成了给定间隔内的所有成员，Rand7WithRand5算法的顺序为10k(约30-70k) 真正的挑战不是编写从Rand(5)生成Rand(7)的方法，而是生成几乎均匀分布的值。

除了我的第一个答案，我想再补充一个答案。这个答案试图最小化每次调用rand7()时对rand5()的调用次数，以最大限度地利用随机性。也就是说，如果你认为随机性是一种宝贵的资源，我们就会尽可能多地利用它，而不丢弃任何随机比特。这个答案也与伊万的回答中的逻辑有一些相似之处。

The entropy of a random variable is a well-defined quantity. For a random variable which takes on N states with equal probabilities (a uniform distribution), the entropy is log2 N. Thus, rand5() has approximately 2.32193 bits of entropy, and rand7() has about 2.80735 bits of entropy. If we hope to maximize our use of randomness, we need to use all 2.32193 bits of entropy from each call to rand5(), and apply them to generating 2.80735 bits of entropy needed for each call to rand7(). The fundamental limit, then, is that we can do no better than log(7)/log(5) = 1.20906 calls to rand5() per call to rand7().

附注:除非另有说明，否则此答案中的所有对数都将以2为底。Rand5()将被假定为返回范围[0,4]的数字，rand7()将被假定为返回范围[0,6]的数字。分别将范围调整为[1,5]和[1,7]是很简单的。

So how do we do it? We generate an infinitely precise random real number between 0 and 1 (pretend for the moment that we could actually compute and store such an infinitely precise number -- we'll fix this later). We can generate such a number by generating its digits in base 5: we pick the random number 0.a1a2a3..., where each digit ai is chosen by a call to rand5(). For example, if our RNG chose ai = 1 for all i, then ignoring the fact that that isn't very random, that would correspond to the real number 1/5 + 1/52 + 1/53 + ... = 1/4 (sum of a geometric series).

Ok, so we've picked a random real number between 0 and 1. I now claim that such a random number is uniformly distributed. Intuitively, this is easy to understand, since each digit was picked uniformly, and the number is infinitely precise. However, a formal proof of this is somewhat more involved, since now we're dealing with a continuous distribution instead of a discrete distribution, so we need to prove that the probability that our number lies in an interval [a, b] equals the length of that interval, b - a. The proof is left as an exercise for the reader =).

现在我们有一个从范围[0,1]中均匀选择的随机实数，我们需要将它转换为范围[0,6]中的一系列均匀随机数，以生成rand7()的输出。我们怎么做呢?与我们刚才所做的正好相反——我们将其转换为以7为底的无限精确小数，然后每个以7为底的数字将对应于rand7()的一个输出。

以前面的例子为例，如果rand5()产生无限的1流，那么我们的随机实数将是1/4。将1/4换算成7为底，我们得到了无穷大小数0.15151515…，因此我们将产生作为输出1,5,1,5,1,5，等等。

好了，我们有了主要的思想，但还有两个问题:我们实际上无法计算或存储一个无限精确的实数，那么我们如何处理它的有限部分呢?第二，我们怎么把它换算成7进制呢?

将0到1之间的数字转换为以7为底的一种方法如下:

乘以7 结果的积分部分是下一个以7为基数的数字 减去积分部分，只留下小数部分 转到第一步

为了处理无限精度的问题，我们计算一个部分结果，并存储结果的上界。也就是说，假设我们调用rand5()两次，两次都返回1。到目前为止，我们生成的数字是0.11(以5为基数)。无论rand5()调用的无限序列的剩余部分产生什么，我们生成的随机实数永远不会大于0.12:0.11≤0.11xyz…< 0.12。

因此，跟踪当前数字到目前为止，以及它可能的最大值，我们将两个数字都转换为以7为底。如果它们对前k位一致，那么我们就可以安全地输出下k位——不管以5为底的无限流是什么，它们永远不会影响以7为底表示的下k位!

这就是生成rand7()的下一个输出的算法，我们只生成rand5()的足够多的数字，以确保我们确定地知道在将随机实数转换为以7为底的过程中下一个数字的值。下面是一个带有测试工具的Python实现:

import random

rand5_calls = 0
def rand5():
    global rand5_calls
    rand5_calls += 1
    return random.randint(0, 4)

def rand7_gen():
    state = 0
    pow5 = 1
    pow7 = 7
    while True:
        if state / pow5 == (state + pow7) / pow5:
            result = state / pow5
            state = (state - result * pow5) * 7
            pow7 *= 7
            yield result
        else:
            state = 5 * state + pow7 * rand5()
            pow5 *= 5

if __name__ == '__main__':
    r7 = rand7_gen()
    N = 10000
    x = list(next(r7) for i in range(N))
    distr = [x.count(i) for i in range(7)]
    expmean = N / 7.0
    expstddev = math.sqrt(N * (1.0/7.0) * (6.0/7.0))

    print '%d TRIALS' % N
    print 'Expected mean: %.1f' % expmean
    print 'Expected standard deviation: %.1f' % expstddev
    print
    print 'DISTRIBUTION:'
    for i in range(7):
        print '%d: %d   (%+.3f stddevs)' % (i, distr[i], (distr[i] - expmean) / expstddev)
    print
    print 'Calls to rand5: %d (average of %f per call to rand7)' % (rand5_calls, float(rand5_calls) / N)

注意，rand7_gen()返回一个生成器，因为它的内部状态涉及到将数字转换为以7为基数。测试工具调用next(r7) 10000次以产生10000个随机数，然后测量它们的分布。只使用整数数学，所以结果是完全正确的。

还要注意，这里的数字变得非常大，非常快。5和7的幂增长很快。因此，在生成大量随机数后，由于大算术，性能将开始明显下降。但请记住，我的目标是最大化随机位的使用，而不是最大化性能(尽管这是次要目标)。

在一次运行中，我对rand5()进行了12091次调用，对rand7()进行了10000次调用，实现了log(7)/log(5)次调用的最小值，平均为4位有效数字，结果输出是均匀的。

为了将这段代码移植到一种没有内置任意大整数的语言中，您必须将pow5和pow7的值限制为本地整型类型的最大值——如果它们变得太大，则重置所有内容并重新开始。这将使每次调用rand7()时对rand5()的平均调用次数略有增加，但希望即使对于32或64位整数也不会增加太多。

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();
?>

在php中

function rand1to7() {
    do {
        $output_value = 0;
        for ($i = 0; $i < 28; $i++) {
            $output_value += rand1to5();
        }
    while ($output_value != 140);
    $output_value -= 12;
    return floor($output_value / 16);
}

循环生成16到127之间的随机数，除以16生成1到7.9375之间的浮点数，然后舍入得到1到7之间的整数。如果我没记错的话，得到7个结果中的任何一个的概率都是16/112。