.net c# 数组缩放int[30]-＞int[50]/int[40]-＞int[20]

        private int[] resizeArray(int[] ratelist, int directsize = 10)
        {
            //rate list
            //int[] ratelist = new int[random.Next(10, 30)];
            //for (var k = 0; k < ratelist.Length; k++)
            //{
            //    ratelist[k] = random.Next(10, 1000);
            //}
            Console.WriteLine("-----------------------------------------------------------");

            for (var k = 0; k < ratelist.Length; k++)
            {
                Console.Write($"{k}::{ratelist[k]},");
            }

            int[] directlist = new int[directsize];

            double voes = Math.Round((double)ratelist.Length / (double)directlist.Length, 2);
            Console.WriteLine($"每个份额:{voes}");


            var hitindex = 0;
            //剩余的还有多少比率给下一个
            double lessrate = 0;
            var rateindex = 0;
            do
            {

                Console.WriteLine($"--开-原:{rateindex} 目标:{hitindex}，结余{lessrate}");

                //缩小 2.2
                if (voes >= 1)
                {
                    #region 处理数组缩小


                    if (lessrate > 0)
                    {
                        //有结余
                        directlist[hitindex] += (int)(ratelist[rateindex] * lessrate);
                        rateindex++;
                        //thisleft = 1 - lessrate;//当前这个还剩余多少

                        var lessneed =Math.Round(voes - lessrate,2);
                        if (lessneed > 0)
                        {
                            if (lessneed > 1)
                            {
                                //2.2
                                var kindex = (int)lessneed;//1.2=1 1.9=1?
                                if (kindex > lessneed) { kindex = kindex - 1; }
                                for (var k = 0; k < kindex; k++) {
                                    directlist[hitindex] += ratelist[rateindex];
                                    rateindex++;
                                }

                                if (rateindex < ratelist.Length)
                                {
                                    var less = lessneed - kindex;
                                    if (less > 0)
                                    {
                                        directlist[hitindex] += (int)(ratelist[rateindex] * less);
                                        lessrate = 1 - less;
                                    }
                                    else
                                    {
                                        lessrate = 0;
                                    }
                                }
                            }
                            else { 
                              

                                directlist[hitindex]+= (int)(ratelist[rateindex] * lessneed);
                                lessrate = 1 - lessneed;
                                if (lessneed == 1) { 
                                  rateindex++;
                                }
                            }
                        }
                        else {
                            lessrate = 0;
                            rateindex++;
                        }

                    }
                    else {
                        //无结余
                        var kindex = (int)voes;
                        if (kindex > voes) { kindex = kindex - 1; }
                        for (var k = 0; k < kindex; k++) {
                            directlist[hitindex] += ratelist[rateindex];
                            rateindex++;
                        }
                        var less = voes - kindex;
                        if (less > 0)
                        {
                            directlist[hitindex] += (int)(ratelist[rateindex] * less);
                            lessrate = 1 - less;
                        }
                        else
                        {
                            lessrate = 0;
                           // rateindex++;
                        }


                    }

                    if (lessrate > 0)
                    {
                        lessrate = Math.Round(lessrate, 2);
                    }
                    #endregion
                }
                else
                {
                    //放大
                    #region 处理数组放大

                    if (lessrate > 0)
                    {
                        if (lessrate > voes)
                        {
                            //剩余的足够下一个使用
                            directlist[hitindex] += (int)(ratelist[rateindex] * voes);
                            lessrate = Math.Round(lessrate - voes, 2);
                        }
                        else
                        {
                            //剩余的不够下一个使用
                            directlist[hitindex] += (int)(ratelist[rateindex] * lessrate);
                            rateindex++;
                            //还需要多个
                            var needrate = Math.Round(voes - lessrate, 2);
                            if (needrate > 0)
                            {
                                directlist[hitindex] += (int)(ratelist[rateindex] * needrate);
                                lessrate = 1 - needrate;
                            }
                            else
                            {
                                lessrate = 0;
                            }
                        }
                    }
                    else
                    {
                        directlist[hitindex] += (int)(ratelist[rateindex] * voes);
                        lessrate = 1 - voes;

                    }
                    #endregion

                }

                if (lessrate > 0)
                {
                    lessrate = Math.Round(lessrate, 2);
                }

             //   Console.WriteLine($"--末-原:{rateindex} 目标:{hitindex}，结余{lessrate}");

                hitindex++;

            } while (hitindex < directlist.Length);


            for (var k = 0; k < directlist.Length; k++)
            {
                Console.Write($"{k}::{directlist[k]},");
            }
            Console.WriteLine();
            Console.WriteLine($"缩放损失：{ratelist.Sum()}:::{directlist.Sum()}");
            Console.WriteLine("==============================================================");
            return directlist;
        }

这个东西干嘛用呢？？？？

计算概率的时候

目前有个问题 估计是要进行缩放，目前采用2位小数，越接近损失越大，估计用4位数，或者原数组进行等比放大，有效果！

转化成字符串描述：

                //rate list
                int[] ratelist = new int[random.Next(1, 10)];
                for (var k = 0; k < ratelist.Length; k++)
                {
                    ratelist[k] = random.Next(100, 1000);
                }

                var newsize = resizeArray(ratelist);

                //.oOHHOo.

                var hightlow = newsize.Max() - newsize.Min();

                var persize = hightlow / 6;

                int[] everysize = new int[6];
                for (var k = 0; k < 6; k++)
                {
                    everysize[k] = newsize.Min() + k * persize;
                }

                var strs = new string[] { ".", "o", "O", "H" };

                var newstrimage = new string[newsize.Length];
                for (var k = 0; k < newsize.Length; k++)
                {

                    var val = newsize[k];
                    newstrimage[k] = strs[0];

                    if (val >= everysize[1])
                    {
                        newstrimage[k] = strs[1];
                    }

                    if (val >= everysize[3])
                    {
                        newstrimage[k] = strs[2];
                    }

                    if (val >= everysize[5])
                    {
                        newstrimage[k] = strs[3];
                    }

                }
                Console.WriteLine("数组数字:" + String.Join("|", newsize));
                Console.WriteLine("图形预览:" + String.Join("", newstrimage));