红包算法

一、完全随机红包

给定总金额，每个红包的金额范围和红包的个数，随机生成符合条件的红包金额。

转成数学语言：n个随机数，总和为sum，每个随机数的范围为[min,max]。求随机方案。

这里先声明一下，什么样的算法是合理的呢，基本需要具备以下两个特点：

1、随机。这里认为生成红包金额一定要随机，即不能出现大量红包金额落在同一值；

2、分布。范围内金额都有得到分配的机会。

（一）、方案一：（其实对于金钱应该用decimal，不用double，这里先忽略这个问题只讨论算法的合理性）

/* n个随机数，总和为sum，每个随机数的范围为[min,max]。
    前n-1个用rand函数随机产生，第n个数设为val=sum-（前n-1数之和）。
（1）若val属于[min,max]，则可以直接用；
（2）若val>=max,则用max。val-max的处理：在1~n-1中随机出一个序号m来，将多出来的val-max补到这第m个数上，如果将其补为200仍然还有剩余，则继续做这样的操作，直到多余部分被分配完为止。
（3）若val<=min，则用min。min-val的处理：在1~n-1中随机出一个序号m来，将多出来的min-val部分从这第m个数上扣除，如果将其削为min仍然没有扣完，则继续这个操作，直到配平为止。*/

    public class RandomGenerator
    {
        /// <summary>
        /// 生成指定个数的限定金额范围的随机红包，且总额为指定值
        /// </summary>
        /// <param name="totalValue">指定总额</param>
        /// <param name="min">最小边界</param>
        /// <param name="max">最大边界</param>
        /// <param name="num">数量</param>
        /// <returns>以列表的形式返回生成的数据</returns>
        public List<double> RandomData(double totalValue, double min, double max, int num, out string message)
        {
            if (min > max)
            {
                message = "min > max，参数错误";
            }
          
            List<double> list = new List<double>();

            //判断参数合理性
            if (min * num == totalValue)
            {
                for (int i = 0; i < num ; i++)
                {
                    list.Add(min);
                }
                message = "fixedValue";
                return list;
            }
            if (min * num > totalValue)
            {
                message = "min * num > totalValue，参数不合理";
                return null;
            }
            if (max * num == totalValue)
            {
                for (int i = 0; i < num; i++)
                {
                    list.Add(max);
                }
                message = "fixedValue";
                return list;
            }
            if (max * num < totalValue)
            {
                message = "max * num < totalValue，参数不合理";
                return null; 
            }
            
            double sum = 0.0;
            Random random = new Random();
            double diffValue = max - min;
           
            double temp;
            //前num-1个数据随机生成
            for (int i = 0; i < num-1; i++)
            {
                temp = Math.Round(random.NextDouble() * diffValue + min, 2);
                sum += temp;
                list.Add(temp);
            }
            //为了保证总额为指定值，须对最后一个数据的生成做处理
            double gap = totalValue-sum;
            if (gap >= min && gap <= max)
            {
                list.Add(gap);
                message = "success";
                return list;
            }
            else if (gap > max)
            {//剩余值大于max
                list.Add(max);
                gap = gap - max;
                int index;
                double value;
                while (gap > 0)
                {
                    index = random.Next(num - 1);  //生成0到num-1之间的随机整数（包括0，不包括num-1）
                    value = list[index];
                    double margin = max - value;
                    if (margin>0)
                    {
                        if (gap >= margin)
                        {
                            list[index] = max;
                            gap = gap - margin;
                        }
                        else 
                        {
                            list[index] = list[index] + gap;
                            message = "success";
                            return list;
                        }
                    }
                }
            }
            else //剩余值小于min
            {
                list.Add(min);
                double need = min-gap;
                int index;
                double value;
                double buffer;
                while (need > 0)
                {
                    index = random.Next(num - 1);  //生成0到num-1之间的随机整数（包括0，不包括num-1）
                    value = list[index];
                    buffer = value - min;
                    if (buffer >= need)
                    {
                        list[index] = list[index] - need;
                        message = "success";
                        return list;
                    }
                    else
                    {
                        list[index] = min;
                        need = need - buffer;
                    }
                }
            }
            message = "success";
            return list;
        }

    }

试验结果：

第一组：min=20；max=150;n=10;sum=1000 

            

第二组：min=50，max=200，n=20000，sum=1200000（部分数据截图如下）

总结：从试验结果来看，这种算法生成的数据并不理想，明显大量的数据落在了范围的分界点上。因此不适用。

结果分析：当平均值远大于最大最小值中位数（中位数代表随机值围绕上线抖动范围）时，会导致随机分配完之后剩余金额较多，而算法采用随机选人进行累加，达到上限后继续随机人员，从而导致大部分人处在上限边界；

反之，平均值小于中位数时，大部分人处于下限边界。

算法尝试改进：

尝试改进一

这里对每个值先在范围内随机赋值，剩余值进行平均加到每个人上，保证原有值的随机性；但是，加入剩余平均值为r_avg，这样计算之后，每个人的金额范围会变为[min+r_avg,  max+r_avg]。

max+r_avg问题会导致某些人加r_avg之后大于最大值，可以尝试把value(i)+r_avg>=max的人排除；

min+r_avg会导致min~min+r_avg之间无人数，尝试计算min~min+r_avg之间应有人数min_n = (max-min)/n  *  r_avg = (max-min)/n  *  r_sum/n = (max-min)*r_sum/n*n，排除这些人。但是这样又会导致[min+avg, min+avg+avg]之间断层。这个问题可以通过随机选n/2来变相解决，但是有点不合理，目前来看没有好的解决方案。

尝试改进二

1）这里对每个值先在范围内随机赋值；

2）遍历每个值，在范围[0,  max-value(i)]内计算个随机值；即random(i)；

3）判断剩余金额r_sum-random(i)的值是否变号。如原r_sum为5，随机金额为7，5-7=-2，即变号；

4）如果变号，取value(i) = value(i) + r_sum，程序终止；

5）如果未变号，value(i) = value(i) + random(i)。继续遍历下个值重复2。

另外，如果剩余值为负，同样道理，只是随机数范围是[0, value(i)-min]，而且遍历每个值要减去这个随机数。

（ 二）、方案二：

 //每个红包先分配min元，其余的再随机分（随机位置在符合金额范围内随机加钱，分完为止）。
    public class RandomGeneratorNew
    {        
        public List<double> RandomData(double totalValue, double min, double max, int num, out string message)
        {
            if (min > max)
            {
                message = "min > max，参数错误";
            }

            List<double> list = new List<double>();

            //判断参数合理性
            if (min * num == totalValue)
            {
                for (int i = 0; i < num; i++)
                {
                    list.Add(min);
                }
                message = "fixedValue";
                return list;
            }
            if (min * num > totalValue)
            {
                message = "min * num > totalValue，参数不合理";
                return null;
            }
            if (max * num == totalValue)
            {
                for (int i = 0; i < num; i++)
                {
                    list.Add(max);
                }
                message = "fixedValue";
                return list;
            }
            if (max * num < totalValue)
            {
                message = "max * num < totalValue，参数不合理";
                return null;
            }

            double left;
            Random random = new Random();
            double diffValue = max - min;

            double tempAdd;
            //每个红包先分配min元
            for (int i = 0; i < num; i++)
            {
                list.Add(min);
            }
            int index;
            double value;
            left=totalValue-min*num;//剩余未分配金额
            while (Math.Round(left,2) > 0)
            { 
                index = random.Next(num - 1);  //生成0到num-1之间的随机整数（包括0，不包括num-1）
                value = list[index];
                double maxMargin = NumMIN(max, left,max-value);
                if (Math.Round(maxMargin, 2) == 0)
                    break;
                tempAdd = Math.Round(random.NextDouble() * maxMargin, 2);
                list[index] = value + tempAdd;
                left -= tempAdd;
            }
            message = "success";
            return list;
        }

        private double NumMIN(double p1, double p2, double p3)
        {
            double temp =  p1 < p2 ? p1 : p2;
            return temp < p3 ? temp : p3;
        }
    
    }

试验结果：

min=1，max=200，n=30000，sum=100000。结果如下（部分数据截图）：

总结：从试验结果来看，这种算法生成的数据并不理想，大部分数据都集中在了最小值上。因此这种算法不能接受。

结果分析：这里之所以出现这种情况，是因为在最小值比较小，中位数（100）远远大于平均值（3）的情况下，再进行剩余金额分配时，刚分配少量几个位置余额就分配完了。

（三）、方案三：

随机撒开，0.01撒开，再撒。即按照0.01随机选择位置进行累加，直至剩余金额为0。

//随机撒开，0.01撒开，再撒
    public class RandomTest
    {
        /// <summary>
        /// 生成指定个数的限定金额范围的随机红包，且总额为指定值
        /// </summary>
        /// <param name="totalValue">指定总额</param>
        /// <param name="min">最小边界</param>
        /// <param name="max">最大边界</param>
        /// <param name="num">数量</param>
        /// <returns>以列表的形式返回生成的数据</returns>
        public List<decimal> RandomData(decimal totalValue, decimal min, decimal max, int num, out string message)
        {
            if (min > max)
            {
                message = "min > max，参数错误";
            }

            List<decimal> list = new List<decimal>();

            //判断参数合理性
            if (min * num == totalValue)
            {
                for (int i = 0; i < num; i++)
                {
                    list.Add(min);
                }
                message = "fixedValue";
                return list;
            }
            if (min * num > totalValue)
            {
                message = "min * num > totalValue，参数不合理";
                return null;
            }
            if (max * num == totalValue)
            {
                for (int i = 0; i < num; i++)
                {
                    list.Add(max);
                }
                message = "fixedValue";
                return list;
            }
            if (max * num < totalValue)
            {
                message = "max * num < totalValue，参数不合理";
                return null;
            }
            Random random = new Random();
            decimal remainder = totalValue;
            int index;       
            //每个红包初始化赋值，先保证min
            for (int i = 0; i < num; i++)
            {
                list.Add(min);
            }
            while (remainder!=0)
            {
                index = random.Next(num);  //生成0到num之间的随机整数（包括0，不包括num）
                if (list[index] + (decimal)0.01 <= max)
                {
                    list[index] += (decimal)0.01;
                    remainder -= (decimal)0.01;
                }
            }
            message = "success";
            return list;
        }

      
    }

试验结果：

min=1，max=200，n=30000，sum=100000。结果如下（部分数据截图）：

总结：从试验结果来看，这种算法生成的数据并不理想，数据比较接近，没有达到在范围内随机的目的。

结果分析：这里因为按照0.01最细粒度进行随机撒开，当金额数量比较大时，随机撒的次数比较多，那么从统计学上来说每个位置被选中的次数比较接近，所以会造成金额比较相近的结果。但是也不能按照粗粒度进行随机撒，这样会造成所有值都是粗粒度的倍数的情况出现。

（四）、方案四：（最终采用的方案）

public List<decimal> RandomData(decimal totalValue, decimal min, decimal max, int num, out string message)
        {
            decimal mu = totalValue / num;
            List<decimal> data;

            if (mu - min <= max - mu)
            {
                data = RandomDataLeft(totalValue, min, max, num, out message);
            }
            else
            {
                data = RandomDataRight(totalValue, min, max, num, out message);
            }
            return data;
        }
        public decimal AdjustData(decimal temp, decimal min, decimal max)//修正数据
        {
            if (temp < min)
            {
                temp = min;
            }
            if (temp > max)
            {
                temp = max;
            }
            return temp;
        }
        public List<decimal> RandomDataLeft(decimal totalValue, decimal min, decimal max, int num, out string message)
        {  //这个方法适用于max-mu>=mu-min的时候
            List<decimal> list = new List<decimal>();

            if (max / (20 + min) >= 2)
                return RandomDataLeftAdjust(totalValue, min, max, num, out message);



            decimal maxMargin = 0;
            //decimal mu = totalValue / num;
            //decimal mu = Math.Round(totalValue / num, 2);
            decimal mu = Math.Round(totalValue / num, 2);
            Random random = new Random();
            decimal diffValue = max - min;
            int count = num;

            decimal factor = mu - min;
            decimal temp;

            //最多可以几个数拼凑
            int maxIndex;
            decimal remainder = (max - min) % factor;
            if (remainder == 0)
                maxIndex = (int)((max - min) / factor);
            else
                maxIndex = (int)((max - min) / factor) + 1;

            decimal a;
            decimal b;
            int index = 2;


            while (count > 1)
            {

                if (count > maxIndex)
                {
                    //正常流程
                    temp = Math.Round((decimal)(random.NextDouble()) * diffValue + min, 2);
                }
                else
                {
                    temp = Math.Round((decimal)(random.NextDouble()) * (count * factor) + min, 2);//当count大于2时，范围边界 min,min+count*factor,最后一个区间：min+(count-1)*factor,min+count*factor;;;当count=2时也通用
                }
                temp = AdjustData(temp, min, max);
                list.Add(temp);
                a = min;
                b = min + 2 * factor;
                while (!(temp >= a && temp <= b))
                {
                    a = b;
                    b += factor;
                    if (b >= max)
                        b = max;
                    index++;
                }
                //此时index的值为多少(n)，就表示需要多少个数，总和为mu*index
                if (index == 2)
                {
                    count -= 2;
                    //list.Add(mu * 2 - temp);
                    if (count == 0)
                        list.Add(totalValue - list.Sum());
                    else
                        list.Add(AdjustData(Math.Round(mu * 2 - temp, 2),min,max));
                    continue;
                }
                decimal partialSum = mu * index;
                count -= index;
                while (index != 2)
                {
                    partialSum = partialSum - temp;
                    maxMargin = partialSum - (index - 2) * min;
                    temp = Math.Round((decimal)(random.NextDouble()) * (maxMargin - min) + min, 2);
                    temp = AdjustData(temp, min, max);
                    list.Add(temp);
                    index--;
                }
                partialSum -= temp;
                if (count == 0)
                {
                    decimal tempSum = list.Sum();
                    list.Add(totalValue - list.Sum());
                }
                else
                    list.Add(AdjustData(Math.Round(partialSum, 2),min,max));
            }
            if (count == 1)
            {
                //list.Add(Math.Round(mu,2));
                decimal tempSum = list.Sum();
                list.Add(totalValue - list.Sum());
            }

            //检验校正

            message = "success";

            list = checkAndAdjust(list,min,max);//看最后一个数据是否符合要求，如果不符合需处理

            //在返回数据之前再打乱一下顺序
            Random RND = new Random(DateTime.Now.Millisecond);
            list = list.OrderBy(x => RND.Next()).ToList();
            return list;
        }

        public List<decimal> checkAndAdjust(List<decimal> list,decimal min, decimal max)
        {
            decimal lastNum = list[list.Count - 1];
            decimal diff;
            Random random = new Random();
            if (lastNum < min)
            {
                list[list.Count - 1] = min;
                diff = min - lastNum;//多算了diff,需从其他元素中减去                               
               
                while(diff!=0)
                {
                    int index = random.Next(list.Count - 1);
                    if (list[index] > min)
                    {
                        if (list[index] - min > diff)
                        {
                            list[index] -= diff;
                            diff = 0;
                        }
                        else if (list[index] - min < diff)
                        {
                            diff = diff - (list[index] - min);//还剩diff需从其他元素中减去
                            list[index] = min;
                        }
                        else { //=
                            list[index] = min;
                            diff = 0;
                        }
                    }
                }
                return list;
            }
            else if (lastNum > max)
            {
                list[list.Count - 1] = max;
                diff = lastNum - max;//少算了diff,需加入其他元素中去
                while (diff != 0)
                { 
                    int index = random.Next(list.Count - 1);
                    if (list[index] < max)
                    {
                        if (max - list[index] > diff)
                        {
                            list[index] += diff;
                            diff = 0;
                        }
                        else if (max - list[index] < diff)
                        {
                            list[index] = max;
                            diff = diff - (max - list[index]);//还剩diff需要加进其他元素中
                        }
                        else
                        {
                            list[index] = max;
                            diff = 0;
                        }
                    }
                }
                return list;
            }
            else //最后一个元素刚好也符合条件，则不需处理
            {
                return list;
            }
        }

        public List<decimal> RandomDataRight(decimal totalValue, decimal min, decimal max, int num, out string message)
        {//这个方法适用于max-mu<mu-min的时候

            List<decimal> list = new List<decimal>();

            decimal minMargin = 0;
            //decimal mu = totalValue / num;
            //decimal mu = Math.Round(totalValue / num, 2);
            decimal mu = Math.Round(totalValue / num, 2);
            Random random = new Random();
            decimal diffValue = max - min;
            int count = num;

            decimal factor = max - mu;
            decimal temp;
            decimal lastNum;
            decimal left;

            //最多可以几个数拼凑
            int maxIndex;
            decimal remainder = (max - min) % factor;
            if (remainder == 0)
                maxIndex = (int)((max - min) / factor);
            else
                maxIndex = (int)((max - min) / factor) + 1;

            decimal a;
            decimal b;
            int index = 2;


            while (count > 1)
            {

                if (count > maxIndex)
                {
                    //正常流程
                    temp = Math.Round((decimal)(random.NextDouble()) * diffValue + min, 2);
                }
                else
                {
                    temp = Math.Round((decimal)(random.NextDouble()) * (count * factor) + max - count * factor, 2);//范围：(max-count*factor,max)
                }
                list.Add(temp);
                a = max - 2 * factor;
                b = max;
                while (!(temp >= a && temp <= b))
                {
                    b = a;
                    a -= factor;
                    if (a < min)
                        a = min;
                    index++;
                }
                //此时index的值为多少(n)，就表示需要多少个数，总和为mu*index
                if (index == 2)
                {
                    count -= 2;
                    if (count == 0)
                    {
                        lastNum = totalValue - list.Sum();
                        if (lastNum <= max)
                            list.Add(lastNum);
                        else
                        {
                            list.Add(max);
                            left = lastNum - max;
                            int pos;
                            while (true)
                            {
                                pos = random.Next(num);
                                if (max - list[pos] >= left)
                                {
                                    list[pos] += left;
                                    break;
                                }
                            }
                        }

                    }
                    else
                        list.Add(Math.Round(mu * 2 - temp, 2));
                    continue;
                }
                decimal partialSum = mu * index;
                count -= index;
                while (index != 2)
                {
                    partialSum = partialSum - temp;
                    minMargin = partialSum - (index - 2) * max;
                    temp = Math.Round((decimal)(random.NextDouble()) * (max - minMargin) + minMargin, 2);
                    list.Add(temp);
                    index--;
                }
                partialSum -= temp;
                if (count == 0)
                {
                    lastNum = totalValue - list.Sum();
                    if (lastNum <= max)
                        list.Add(lastNum);
                    else
                    {
                        list.Add(max);
                        left = lastNum - max;
                        int pos;
                        while (true)
                        {
                            pos = random.Next(num);
                            if (max - list[pos] >= left)
                            {
                                list[pos] += left;
                                break;
                            }
                        }
                    }
                }
                else
                    list.Add(Math.Round(partialSum, 2));
            }
            if (count == 1)
            {
                lastNum = totalValue - list.Sum();
                if (lastNum <= max)
                    list.Add(lastNum);
                else
                {
                    list.Add(max);
                    left = lastNum - max;
                    int pos;
                    while (true)
                    {
                        pos = random.Next(num);
                        if (max - list[pos] >= left)
                        {
                            list[pos] += left;
                            break;
                        }
                    }
                }
            }

            //检验校正

            message = "success";
            list = checkAndAdjust(list, min, max);//看最后一个数据是否符合要求，如果不符合需处理
            //在返回数据之前再打乱一下顺序
            Random RND = new Random(DateTime.Now.Millisecond);
            list = list.OrderBy(x => RND.Next()).ToList();
            return list;
        }

        private List<decimal> RandomDataLeftAdjust(decimal totalValue, decimal min, decimal max, int num, out string message)
        {

            List<decimal> list = new List<decimal>();

            int ratio;//概率比例调整倍数
            int maxReduce;//最大值缩小倍数

            int tempMaxReduce = (int)(max % (20 + min));
            if (tempMaxReduce == 0)
                maxReduce = (int)(max / (20 + min));
            else
            {
                maxReduce = (int)(max / (20 + min)) + 1;
                if (maxReduce >= max / min)
                    maxReduce--;
            }

            int tempRatio = num / 5;
            ratio = tempRatio > 200 ? 200 : tempRatio;

            decimal maxMargin = 0;
            //decimal mu = totalValue / num;
            //decimal mu = Math.Round(totalValue / num, 2);
            decimal mu = Math.Round(totalValue / num, 2);
            Random random = new Random();
            decimal diffValue = max - min;
            int count = num;

            decimal factor = mu - min;
            decimal temp;

            //最多可以几个数拼凑
            int maxIndex;
            decimal remainder = (max - min) % factor;
            if (remainder == 0)
                maxIndex = (int)((max - min) / factor);
            else
                maxIndex = (int)((max - min) / factor) + 1;

            decimal a;
            decimal b;
            int index = 2;

            int flag = 1;
            int mode;
            decimal modediffValue = max / maxReduce - min;  //缩小多少倍，这个参数10可根据实际情况来调节     ！！小心会不会出现max/10<min的情况？？？

            while (count > 1)
            {
                if (flag % ratio == 0)   //这个比例的控制也可以根据实际情况来调节
                    mode = 1;
                else
                    mode = 0;
                flag++;
                if (count > maxIndex)
                {
                    //正常流程

                    if (mode == 1)
                        temp = Math.Round((decimal)(random.NextDouble()) * diffValue + min, 2);
                    else
                        temp = Math.Round((decimal)(random.NextDouble()) * modediffValue + min, 2);
                }
                else
                {
                    if (mode == 1)
                        temp = Math.Round((decimal)(random.NextDouble()) * (count * factor) + min, 2);//当count大于2时，范围边界 min,min+count*factor,最后一个区间：min+(count-1)*factor,min+count*factor
                    else
                    {
                        decimal tempMargin = (count * factor) < modediffValue ? (count * factor) : modediffValue;
                        temp = Math.Round((decimal)(random.NextDouble()) * tempMargin + min, 2);
                    }
                }
                temp = AdjustData(temp, min, max);
                list.Add(temp);
                a = min;
                b = min + 2 * factor;
                while (!(temp >= a && temp <= b))
                {
                    a = b;
                    b += factor;
                    if (b >= max)
                        b = max;
                    index++;
                }
                //此时index的值为多少(n)，就表示需要多少个数，总和为mu*index
                if (index == 2)
                {
                    count -= 2;
                    //list.Add(mu * 2 - temp);
                    if (count == 0)
                        list.Add(totalValue - list.Sum());
                    else
                        list.Add(AdjustData(Math.Round(mu * 2 - temp, 2),min,max));
                    continue;
                }
                decimal partialSum = mu * index;
                count -= index;
                while (index != 2)
                {
                    partialSum = partialSum - temp;
                    maxMargin = partialSum - (index - 2) * min;
                    temp = Math.Round((decimal)(random.NextDouble()) * (maxMargin - min) + min, 2);
                    temp = AdjustData(temp, min, max);
                    list.Add(temp);
                    index--;
                }
                partialSum -= temp;
                if (count == 0)
                {
                    decimal tempSum = list.Sum();
                    list.Add(totalValue - list.Sum());
                }
                else
                    list.Add(AdjustData(Math.Round(partialSum, 2),min,max));
            }
            if (count == 1)
            {
                //list.Add(Math.Round(mu,2));
                decimal tempSum = list.Sum();
                list.Add(totalValue - list.Sum());
            }

            //检验校正

            message = "success";
            //在返回数据之前再打乱一下顺序
            Random RND = new Random(DateTime.Now.Millisecond);
            list = list.OrderBy(x => RND.Next()).ToList();
            return list;
        }

二、符合正态分布的随机红包

给定总金额，每个红包的金额范围和红包的个数，随机生成符合正态分布的红包金额。

转成数学语言：n个随机数，总和为sum，每个随机数的范围为[min,max]，要求数据符合正态分布。求随机方案。

/// <summary>
        ///  生成符合正态分布的随机数据
        /// </summary>
        /// <param name="r"></param>
        /// <param name = "mu">Mean of the distribution</param>
        /// <param name = "sigma">Standard deviation</param>
        /// <returns></returns>
        private decimal NextGaussian(Random r, decimal mu = 0, decimal sigma = 1)
        {
            var u1 = r.NextDouble();
            var u2 = r.NextDouble();
            var rand_std_normal = (decimal)(Math.Sqrt(-2.0 * Math.Log(u1)) *
                                Math.Sin(2.0 * Math.PI * u2));

            var rand_normal = mu + sigma * rand_std_normal;

            return rand_normal;
        }
        public List<decimal> NorDist(decimal totalValue, decimal min, decimal max, int num, out string message)
        {
            try
            {
                decimal mu = (max + min) / 2;
                decimal sigma = (max - mu) / 3;
                decimal tempSum = 0;

                var r = new Random();
                List<decimal> list = new List<decimal>();
                decimal randomData;
                for (int i = 0; i < num - 1; i++)  //先生成前num-1个数据
                {
                    randomData = NextGaussian(r, mu, sigma);
                    for (; randomData < min || randomData > max; )
                        randomData = NextGaussian(r, mu, sigma);
                    randomData = Math.Round(randomData, 2);
                    tempSum += randomData;
                    list.Add(randomData);
                }
                decimal diff = totalValue - tempSum;
                if (diff >= min && diff <= max)
                {
                    tempSum += diff;
                    list.Add(diff);
                    message = "success";
                    return list;
                }
                else
                {
                    decimal miniUnit = 0.1M;
                    randomData = NextGaussian(r, mu, sigma);
                    for (; randomData < min || randomData > max; )
                        randomData = NextGaussian(r, mu, sigma);
                    randomData = Math.Round(randomData, 2);
                    tempSum += randomData;
                    list.Add(randomData);
                    diff = totalValue - tempSum;
                    int k = -1;
                    decimal n;

                    if (diff > 0)
                    {  //即预定资金没用完
                        for (n = diff; n >= miniUnit; n = n - miniUnit)
                        {
                            k = (k + 1) % num;
                            while (list[k] > max - miniUnit)
                            {
                                k = (k + 1) % num;
                            }
                            list[k] += miniUnit;
                        }
                        if (n != 0)
                        {
                            while (list[k] + n > max)
                            {
                                if (k > 0)
                                    k = k - 1;
                                else
                                {
                                    message = "正态分布分配失败，请重试";
                                    return null;  //分配失败
                                }
                            }
                            list[k] += n;
                        }
                    }
                    else //即diff<0，不可能出现=0的情况   ,此时分配资金超出预定，需要回收
                    {
                        diff = -diff;
                        for (n = diff; n >= miniUnit; n = n - miniUnit)
                        {
                            k = (k + 1) % num;
                            while (list[k] < min + miniUnit)
                            {
                                k = (k + 1) % num;
                            }
                            list[k] -= miniUnit;
                        }
                        if (n != 0)
                        {
                            while (list[k] - n < min)
                            {
                                if (k > 0)
                                    k = k - 1;
                                else
                                {
                                    message = "正态分布分配失败，请重试";
                                    return null;  //分配失败
                                }
                            }
                            list[k] -= n;
                        }
                    }
                }

                message = "success";
                return list;
            }
            catch (Exception ex)
            {
                Logger.Error("HRPortal -> NorDist方法异常", ex);
                message = "分配金额失败，请重试";
                return null;
            }
        }

 三、网上找到的例子：（生成随机红包一）

（1）https://www.zhihu.com/question/22625187

（2）

/**
 * 计算随机值
 * @input:  min  最小金额(默认为1, 0.01元)
 *          max 最大金额(默认为20000， 200元)
 *          total 剩余总金额
 *          num 剩余总人数
 * @return: 本次随机金额
 */
LONG HbReceive::calcRandomValue(LONG min, LONG max, LONG total, LONG num) 
  throw (CException)
{
    if(num == 1)
    {
        return total;
    }
 
    // 更新随机种子
    srand(time(NULL));
 
    // 确定本次随机范围
    LONG low = (total - (num-1)*max) < min ? min : total - (num-1)*max;
 
    LONG high = (total - (num-1)*min) > max ? max : (total - (num-1)*min);
 
    LONG ave = total / num > 1 ? total / num : 1;
 
    // 调整上限
    if(high > 2 * ave)   high = 2 * ave;
 
    // 生成随机值
    LONG ram = random() % high;
 
    // 防止溢出
    if(ram < low) ram = low;
 
    if(ram > high) ram = high;
 
    return ram;
}

输出到文件中代码：

 public void outputToFile(List<decimal> list)
        {
            FileStream fs = new FileStream("D:\RandomTest.txt", FileMode.Append);
            StreamWriter sw = new StreamWriter(fs, Encoding.Default);
            foreach (var item in list)
            {
                //sw.WriteLine(item);
                sw.Write(item); sw.Write('	');
            }
            sw.Close();
            fs.Close();
        }