我们先来看这样一个问题， 已知rand5能等概率产生1, 2, 3, 4, 5， 现要用rand5来实现rand7（rand7的意思是要等概率产生1, 2, 3, 4, 5, 6, 7）, 该怎么搞呢？ 我看了一下网上资料， 很多都是凑出来一个结果， 没有什么过程思路， 我觉得虽然结果正确， 但总感觉所用的技巧性太强。 所以， 在文本中， 我也来凑凑热闹， 看看该如何下手， 并给出程序的实际验证结果。
我们看看rand5 + rand5 行不行。 rand5 + rand5 的结果是2, 3, 4, 5, 6, 7, 8, 9, 10, 稍微思考一下， 就知道， 这些数肯定不是等概率的， 比如2的概率要低于5的概率。 所以， 不靠谱。 我们再来看看， 既然有了1, 2, 3, 4, 5, 那很容易就有10, 20, 30, 40, 50, 且是等概率的。 假设现在又有另外一个fun函数， 能等概率随机生成0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 那么， 我们不就很轻易地构造了等概率的10, 11, 12, 13, ....., 59么？ 没错， 思路就是这样的。
所以， 我们先要让rand5产生等概率的间距数组（比如上述的10, 20, 30, 40, 50,）， 然后让rand5产生连续的待插入数字（比如上述的0, 1, 2, ..., 9,）. 现在问题是， 要多大的间距才合适呢？ 其实也很简单， 要让0, 1, 2, 3, 4刚好能插入到间距数组中。
到这里， 就比较俗套了：
第一步： 用rand5产生等概率的0, 1, 2, 3, 4，准备插入到下一步的等间距数组中, 使得插入后， 刚好合适。
第二步： 用rand5产生等概率的0, 1, 2, 3, 4, 然后为了被插入， 将其散开成0, 5, 10, 15, 20.
第三步： 将第一步插入 到第二步中， 于是， 就形成了0， 1， 2， 3， 4， 5， 6， 7， 8， ...， 20， 21， 22， 23， 24. 然后就很容易等概率地生成1, 2, 3, 4, 5, 6, 7了。
题目：
给定一个函数rand5()，该函数可以随机生成1-5的整数，且生成概率一样。现要求使用该函数构造函数rand7()，使函数rand7()可以随机等概率的生成1-7的整数。
思路：
很多人的第一反应是利用rand5() + rand()%3来实现rand7()函数，这个方法确实可以产生1-7之间的随机数，但是仔细想想可以发现数字生成的概率是不相等的。rand()%3 产生0的概率是1/5，而产生1和2的概率都是2/5，所以这个方法产生6和7的概率大于产生5的概率。
正确的方法是利用rand5()函数生成1-25之间的数字，然后将其中的1-21映射成1-7，丢弃22-25。例如生成(1，1)，(1，2)，(1，3)，则看成rand7()中的1，如果出现剩下的4种，则丢弃重新生成。
简单实现：
Java代码
- public class Test {
- public int rand7() {
- int x = 22;
- while(x > 21) {
- x = rand5() + (rand5() - 1)*5;
- }
- return 1 + x%7;
- }
- }
rand5() 它能够等概率生成 1-5 之间的整数。所谓等概率就是1,2,3,4,5 生产的概率均为 0.2 。现在利用rand5(), 构造一个能够等概率生成 1- 7 的方法。这里有两个特别重要的点，一是 如果 rand5() + rand5(), 我们能够产生一个均匀分布的 1 - 10 吗？ 答案是否定的。比如对于 6来讲（4+2， 2+4， 3+3），它被生成的生成的概率比1 （1+0，0+1）要大。
第二个点就是我们不可能用rand5()直接产生 1- 7 的数，不管你用加减乘除都不行。所以，我们要构造一个更大的范围，使得范围里每一个值被生成的概率是一样的，而且这个范围是7的倍数。
先产生一个均匀分布的 0， 5， 10， 15， 20的数，再产生一个均匀分布的 0， 1， 2， 3， 4 的数。相加以后，会产生一个 0到24的数，而且每个数（除0外）生成的概率是一样的。我们只取 1 - 21 这一段，和7 取余以后+1就能得到完全均匀分布的1-7的随机数了。
我的备注：
这种思想是基于，rand()产生[0,N-1]，把rand()视为N进制的一位数产生器，那么可以使用rand()*N+rand()来产生2位的N进制数，以此类推，可以产生3位，4位，5位...的N进制数。这种按构造N进制数的方式生成的随机数，必定能保证随机，而相反，借助其他方式来使用rand()产生随机数(如 rand5() + rand()%3 )都是不能保证概率平均的。
此题中N为5，因此可以使用rand5()*5+rand5()来产生2位的5进制数，范围就是1到25。再去掉22-25，剩余的除3，以此作为rand7()的产生器.
给定一个函数rand()能产生0到n-1之间的等概率随机数，问如何产生0到m-1之间等概率的随机数？
- int random(int m,int n){
- int k=rand();
- int max=n-1;
- while(k<m){
- k=k*n+rand();
- max=max*n+n-1;
- }
- return k/(max/n);
- }
如何产生如下概率的随机数？0出1次，1出现2次，2出现3次，n-1出现n次？
- int random(int size){
- while(true){
- int m=rand(size);
- int n=rand(size);
- if(m+n<size)
- return m+n;
- }
- }
5.1-2 描述random(a,b)过程的一种实现，它只调用random(0,1).作为a和b的函数，你的程序的期望运行时间是多少？
注：random(a,b)为产生a,a+1,a+2,...,b的函数发生器，且产生各整数的概率相等，同为1/(b - a + 1)．
看到这个题目时，似曾相识，脑海浮现了利用random(0,1)产生0或1，从而组成二进制数，来完成random(a,b)的实现．但是细想以后，感觉有个问题在脑海中有点不明不白．
运行random(0,1)函数k次，使得2k>=(b-a+1)，将得到[0,2k)的整数区间，如何将[0,2k)映射到[a,b]的整数区间，保证产生各整数的概率相等，同为1/(b-a+1).
1.当存在k使得2k=(b-a+1)时，只需将产生的二进制数与[a,b]整数一一对应，即可满足概率同为1/(b-a+1)的要求．
例如，random(3,6)，k=2. 此时，对应关系可为00~3,01~4,10~5,11~6．产生的概率为1/4.
2.当不存在k使得2k=(b-a+1)时，产生[0,2k)区间整数的概率为1/2k，小于1/(b-a+1)．[0,2k)如何映射到[a,b]整数区间．
思路一：扩大[0,2k)区间，使得2k可以被(b-a+1)整除，这样可以把[0,2k)分成N段时，每一段对应[a,b]里的一个整数．
但这个思路，是不可行的，因为不存在这样的k值．要么2k=(b-a+1)，要么2k>(b-a+1)且不可被(b-a+1)整除．
思路二：参取截断映射，即 [0,2k) 的前部分映射到[a,b]，这样虽然可以达到产生整数的概率相等，但不等于1/(b-a+1)，还有如果产生[0,2k)后部分的值如何处理．
这个思路，是可行的，如果产生后部分的值，就继续调用自身，重新random.从结果输出分析，最终random(a,b)最终输出的只有[a,b]里的整数，而且每个整数的概率相等，因而其产生的概率值是1/(b-a+1).
具体的实现代码如下：
int random(int a,int b) { int m = 1; int len = b - a + 1; int k = 0; //计算最小的正整数k,使2^k >= len while(m < len) { k++; m *= 2; } m = 0; for(int i = 0;i < k;i++) { m += random(0,1) * (1<<i); } if(m + 1 > len) { return random(a,b); } else { return m + a; } }
由于冗余的存在，该方法运行时间最坏的情况是无究，就是无限地递归调用自身．运行时间的下限是O(log(b-a+1)).
由上述的练习题可扩展出更多类似的问题．
利用rand5()产生rand7()．rand5()产生1到5的整数，rand7()产生1到7的整数．
解决思路与上述的练习题是一样的．利用rand5()产生的一个整数空间，然后将其映射到[1,7]的整数空间上，映射时保证概率相等，且等于1/7.
下面介绍几个有意思的实现．
1.利用预置数组 该方法简单，易理解，但是不具扩展性，需要额外存储空间．
1 int rand7() 2 { 3 int vals[5][5] = { 4 {1,2,3,4,5}, 5 {6,7,1,2,3}, 6 {4,5,6,7,1}, 7 {2,3,4,5,6}, 8 {7,0,0,0,0} 9 }; 10 int result = 0; 11 while(result == 0) 12 { 13 int i = rand5(); 14 int j = rand5(); 15 result = vals[i - 1][j - 1]; 16 } 17 return result; 18 }
2.常规实现方法 可扩展，主要分为三步，构造大的整数区间，限制整数区间，最后映射整数区间．
1 int rand7() 2 { 3 int i; 4 do{ 5 i = 5 * (rand5() - 1) + rand5(); //产生[1,25]的整数区间 6 }while(i > 21); //将[1,25]整数区间控制于[1,21] 7 return i%7 + 1; //将[1,21]映射到[1,7] 8 }
3.看似正确的方法 其实错误的方法
1 int rand7() 2 { 3 int i; 4 i = rand5() + rand5() + rand5() + rand5() + rand5() + rand5() + rand5(); 5 return i%7 + 1; 6 }
与方法2的思路一样，构造新的整数区间，但是方法3中构造的整数区间并不是等概率的．
第4代码中，将会产生5^7种可能的计算，但最终这些可能映射到[7,35]的整数区间中，但是[7,35]区间内整数的产生的概率并不相等．
例如，通过累加区间[0,1]三次，可以得到[0,3]的区间，但是[0,3]每个整数的概率并不相等，分别为1/8,3/8,3/8,1/8．
题目
给你一个能生成1到5随机数的函数，用它写一个函数生成1到7的随机数。 (即：使用函数rand5()来实现函数rand7())。
解答
rand5可以随机生成1,2,3,4,5；rand7可以随机生成1,2,3,4,5,6,7。 rand5并不能直接产生6，7，所以直接用rand5去实现函数rand7似乎不太好入手。 如果反过来呢？给你rand7，让你实现rand5，这个好实现吗？
一个非常直观的想法就是不断地调用rand7，直到它产生1到5之间的数，然后返回。 代码如下：
int Rand5(){ int x = ~(1<<31); // max int while(x > 5) x = Rand7(); return x; }
| 1 2 3 4 5 6 | int Rand5(){ int x = ~(1<<31); // max int while(x > 5) x = Rand7(); return x; } |
等等，这个函数可以等概率地产生1到5的数吗？首先，它确确实实只会返回1到5这几个数， 其次，对于这些数，都是由Rand7等概率产生的(1/7)，没有对任何一个数有偏袒， 直觉告诉我们，Rand5就是等概率地产生1到5的。事实呢？让我们来计算一下， 产生1到5中的数的概率是不是1/5就OK了。比如说，让我们来计算一下Rand5生成1 的概率是多少。上面的函数中有个while循环，只要没生成1到5间的数就会一直执行下去。 因此，我们要的1可能是第一次调用Rand7时产生，也可能是第二次，第三次，…第n次。 第1次就生成1，概率是1/7；第2次生成1，说明第1次没生成1到5间的数而生成了6，7， 所以概率是(2/7)*(1/7)，依次类推。生成1的概率计算如下：
P(x=1)=1/7 + (2/7) * 1/7 + (2/7)^2 * 1/7 + (2/7)^3 * 1/7 + ... =1/7 * (1 + 2/7 + (2/7)^2 + ...) // 等比数列 =1/7 * 1 / (1 - 2/7) =1/7 * 7/5 =1/5
| 1 2 3 4 5 6 | P(x=1)=1/7 + (2/7) * 1/7 + (2/7)^2 * 1/7 + (2/7)^3 * 1/7 + ... =1/7 * (1 + 2/7 + (2/7)^2 + ...) // 等比数列 =1/7 * 1 / (1 - 2/7) =1/7 * 7/5 =1/5
|
上述计算说明Rand5是等概率地生成1,2,3,4,5的(1/5的概率)。从上面的分析中， 我们可以得到一个一般的结论，如果a > b，那么一定可以用Randa去实现Randb。其中， Randa表示等概率生成1到a的函数，Randb表示等概率生成1到b的函数。代码如下：
// a > b int Randb(){ int x = ~(1<<31); // max int while(x > b) x = Randa(); return x; }
| 1 2 3 4 5 6 7 | // a > b int Randb(){ int x = ~(1<<31); // max int while(x > b) x = Randa(); return x; } |
回到正题，现在题目要求我们要用Rand5来实现Rand7，只要我们将Rand5 映射到一个能产生更大随机数的Randa，其中a > 7，就可以套用上面的模板了。 这里要注意一点的是，你映射后的Randa一定是要满足等概率生成1到a的。比如，
Rand5() + Rand5() - 1
| 1 2 | Rand5() + Rand5() - 1
|
上述代码可以生成1到9的数，但它们是等概率生成的吗？不是。生成1只有一种组合： 两个Rand5()都生成1时：(1, 1)；而生成2有两种：(1, 2)和(2, 1)；生成6更多。 它们的生成是不等概率的。那要怎样找到一个等概率生成数的组合呢？
我们先给出一个组合，再来进行分析。组合如下：
5 * (Rand5() - 1) + Rand5()
| 1 2 | 5 * (Rand5() - 1) + Rand5()
|
Rand5产生1到5的数，减1就产生0到4的数，乘以5后可以产生的数是：0,5,10,15,20。 再加上第二个Rand5()产生的1,2,3,4,5。我们可以得到1到25， 而且每个数都只由一种组合得到，即上述代码可以等概率地生成1到25。OK， 到这基本上也就解决了。
套用上面的模板，我们可以得到如下代码：
int Rand7(){ int x = ~(1<<31); // max int while(x > 7) x = 5 * (Rand5() - 1) + Rand5() // Rand25 return x; }
| 1 2 3 4 5 6 | int Rand7(){ int x = ~(1<<31); // max int while(x > 7) x = 5 * (Rand5() - 1) + Rand5() // Rand25 return x; } |
上面的代码有什么问题呢？可能while循环要进行很多次才能返回。 因为Rand25会产生1到25的数，而只有1到7时才跳出while循环， 生成大部分的数都舍弃掉了。这样的实现明显不好。我们应该让舍弃的数尽量少， 于是我们可以修改while中的判断条件，让x与最接近25且小于25的7的倍数相比。 于是判断条件可改为x > 21，于是x的取值就是1到21。 我们再通过取模运算把它映射到1-7即可。代码如下：
int Rand7(){ int x = ~(1<<31); // max int while(x > 21) x = 5 * (Rand5() - 1) + Rand5() // Rand25 return x%7 + 1; }
| 1 2 3 4 5 6 | int Rand7(){ int x = ~(1<<31); // max int while(x > 21) x = 5 * (Rand5() - 1) + Rand5() // Rand25 return x%7 + 1; } |
这个实现就比上面的实现要好，并且可以保证等概率生成1到7的数。
让我们把这个问题泛化一下，从特殊到一般。现在我给你两个生成随机数的函数Randa， Randb。Randa和Randb分别产生1到a的随机数和1到b的随机数，a，b不相等 (相等就没必要做转换了)。现在让你用Randa实现Randb。
通过上文分析，我们可以得到步骤如下：
- 如果a > b，进入步骤2；否则构造Randa2 = a * (Randa – 1) + Randa， 表示生成1到a2 随机数的函数。如果a2 仍小于b，继教构造 Randa3 = a * (Randa2 - 1) + Randa…直到ak > b，这时我们得到Randak , 我们记为RandA。
- 步骤1中我们得到了RandA(可能是Randa或Randak )，其中A > b， 我们用下述代码构造Randb：
// A > b int Randb(){ int x = ~(1<<31); // max int while(x > b*(A/b)) // b*(A/b)表示最接近A且小于A的b的倍数 x = RandA(); return x%b + 1; }
1
2
3
4
5
6
7
// A > b
int Randb(){
int x = ~(1<<31); // max int
while(x > b*(A/b)) // b*(A/b)表示最接近A且小于A的b的倍数
x = RandA();
return x%b + 1;
}
从上面一系列的分析可以发现，如果给你两个生成随机数的函数Randa和Randb， 你可以通过以下方式轻松构造Randab，生成1到a*b的随机数。Randab = b * (Randa - 1) + Randb Randab = a * (Randb - 1) + Randa
1
2
3
Randab = b * (Randa - 1) + Randb
Randab = a * (Randb - 1) + Randa
如果再一般化一下，我们还可以把问题变成：给你一个随机生成a到b的函数， 用它去实现一个随机生成c到d的函数。
488
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
