抢红包的红包生成算法

过年微信红包很火，最近有个项目也要做抢红包，于是写了个红包的生成算法。

红包生成算法的需求

预先生成所有的红包还是一个请求随机生成一个红包

简单来说，就是把一个大整数m分解（直接以“分为单位，如1元即100）分解成n个小整数的过程，小整数的范围是[min, max]。

最简单的思路，先保底，每个小红包保证有min，然后每个请求都随机生成一个0到(max-min)范围的整数，再加上min就是红包的钱数。

这个算法虽然简单，但是有一个弊端：最后生成的红包可能都是min钱数的。也就是说可能最后的红包都是0.01元的。

另一种方式是预先生成所有红包，这样就比较容易控制了。我选择的是预先生成所有的红包。

理想的红包生成算法

理想的红包生成结果是平均值附近的红包比较多，大红包和小红包的数量比较少。

可以想像下，生成红包的数量的分布有点像正态分布。

那么如何实现这种平均线附近值比较多的要求呢？

就是要找到一种算法，可以提高平均值附近的概率。那么利用一种”膨胀“再”收缩“的方式来达到这种效果。

先平方，再生成平方范围内的随机数，再开方，那么概率就不再是平均的了。

具体算法：

[java] view plain copy

 

1. public class HongBaoAlgorithm {  
2.     static Random random = new Random();  
3.     static {  
4.         random.setSeed(System.currentTimeMillis());  
5.     }  
6.       
7.     public static void main(String[] args) {  
8.         long max = 200;  
9.         long min = 1;  
10.   
11.         long[] result = HongBaoAlgorithm.generate(100_0000, 10_000, max, min);  
12.         long total = 0;  
13.         for (int i = 0; i < result.length; i++) {  
14.             // System.out.println("result[" + i + "]:" + result[i]);  
15.             // System.out.println(result[i]);  
16.             total += result[i];  
17.         }  
18.         //检查生成的红包的总额是否正确  
19.         System.out.println("total:" + total);  
20.   
21.         //统计每个钱数的红包数量，检查是否接近正态分布  
22.         int count[] = new int[(int) max + 1];  
23.         for (int i = 0; i < result.length; i++) {  
24.             count[(int) result[i]] += 1;  
25.         }  
26.   
27.         for (int i = 0; i < count.length; i++) {  
28.             System.out.println("" + i + "  " + count[i]);  
29.         }  
30.     }  
31.       
32.     /** 
33.      * 生产min和max之间的随机数，但是概率不是平均的，从min到max方向概率逐渐加大。 
34.      * 先平方，然后产生一个平方值范围内的随机数，再开方，这样就产生了一种“膨胀”再“收缩”的效果。 
35.      *  
36.      * @param min 
37.      * @param max 
38.      * @return 
39.      */  
40.     static long xRandom(long min, long max) {  
41.         return sqrt(nextLong(sqr(max - min)));  
42.     }  
43.   
44.     /** 
45.      *  
46.      * @param total 
47.      *            红包总额 
48.      * @param count 
49.      *            红包个数 
50.      * @param max 
51.      *            每个小红包的最大额 
52.      * @param min 
53.      *            每个小红包的最小额 
54.      * @return 存放生成的每个小红包的值的数组 
55.      */  
56.     public static long[] generate(long total, int count, long max, long min) {  
57.         long[] result = new long[count];  
58.   
59.         long average = total / count;  
60.   
61.         long a = average - min;  
62.         long b = max - min;  
63.   
64.         //  
65.         //这样的随机数的概率实际改变了，产生大数的可能性要比产生小数的概率要小。  
66.         //这样就实现了大部分红包的值在平均数附近。大红包和小红包比较少。  
67.         long range1 = sqr(average - min);  
68.         long range2 = sqr(max - average);  
69.   
70.         for (int i = 0; i < result.length; i++) {  
71.             //因为小红包的数量通常是要比大红包的数量要多的，因为这里的概率要调换过来。  
72.             //当随机数>平均值，则产生小红包  
73.             //当随机数<平均值，则产生大红包  
74.             if (nextLong(min, max) > average) {  
75.                 // 在平均线上减钱  
76. //              long temp = min + sqrt(nextLong(range1));  
77.                 long temp = min + xRandom(min, average);  
78.                 result[i] = temp;  
79.                 total -= temp;  
80.             } else {  
81.                 // 在平均线上加钱  
82. //              long temp = max - sqrt(nextLong(range2));  
83.                 long temp = max - xRandom(average, max);  
84.                 result[i] = temp;  
85.                 total -= temp;  
86.             }  
87.         }  
88.         // 如果还有余钱，则尝试加到小红包里，如果加不进去，则尝试下一个。  
89.         while (total > 0) {  
90.             for (int i = 0; i < result.length; i++) {  
91.                 if (total > 0 && result[i] < max) {  
92.                     result[i]++;  
93.                     total--;  
94.                 }  
95.             }  
96.         }  
97.         // 如果钱是负数了，还得从已生成的小红包中抽取回来  
98.         while (total < 0) {  
99.             for (int i = 0; i < result.length; i++) {  
100.                 if (total < 0 && result[i] > min) {  
101.                     result[i]--;  
102.                     total++;  
103.                 }  
104.             }  
105.         }  
106.         return result;  
107.     }  
108.   
109.     static long sqrt(long n) {  
110.         // 改进为查表？  
111.         return (long) Math.sqrt(n);  
112.     }  
113.   
114.     static long sqr(long n) {  
115.         // 查表快，还是直接算快？  
116.         return n * n;  
117.     }  
118.       
119.     static long nextLong(long n) {  
120.         return random.nextInt((int) n);  
121.     }  
122.   
123.     static long nextLong(long min, long max) {  
124.         return random.nextInt((int) (max - min + 1)) + min;  
125.     }  
126. }  

统计了下生成的结果，还是比较符合要求的。