java 指定平均值和取值范围生成随机数（随机100到10000平均值是1000，最大值，最小值）

需求场景：抽奖送积分，积分范围100-10000，要求平均1000积分。

这是一个很常见的需求，但是很难下手，一般人的解决方案都是先随机几个数值判断或者第一次随机一个小的第二次随机一个大的。

其实如果把需求转换成数学函数你就会豁然开朗：

给定离散函数y=f(x)(x∈[100,10000],y>=0,)，使得y的期望值为1000。

但，这种函数千千万，鬼知道是哪个...

正所谓弱水三千我们只需一瓢，我们又不是来解数学题的，只要找到一个符合条件的不就行了。

首先这个函数必须是曲线，所以我们就取最简单的曲线y=ax²和y=1/ax。

博主身先士卒，试过了y=ax²并不行，所以此处选择y=1/ax的双曲线。

还是那句话弱水三千我们只需一瓢，越简单越好所以直接指定a=1，为了更方便计算，我们再指定x=1时y=0，这样就选好了一个双曲线y=1/x-1。然后根据数学函数的特性，我们只需要找到区间[m,1]，最大值f(m)，最小值0，平均值是1000/(10000-100)*f(m)（就是y值的0.1010101倍）就可以解决随机的问题了。

定积分肯定少不了了：

x=1时y=0所以平均值就是：dx/(1-m)

回回神，整个逻辑梳理一下，最终的结果就是：(-ln(m)-(1-m))/(1-m)=平均值，平均值=0.1010101*(1/m-1)，求m的值。

虽然已经简化这么多，但博主反正是求不出来这个m的值。

仍然是那句话我们又不是来解数学题的，既然解不出来，作为程序猿怎么能忘记初心呢：我们只需要用代码递归找到一个m使得平均值比例最趋近0.101010101不就行了。

函数y=1/x-1在(0,1)区间内是单调减的，所以直接采用二分法，然后递归调用。结合代码的特性：double值是有限的，所以只需要二分法后的值等于二分法左值、二分法右值、平均值中的一个就可以结束了。

此处需要注意的是y=1/x-1的平均值和最大值的比例只会小于0.5，举例就是：最小值100，最大值10000，则这个曲线最大只能生成平均值为5049.99999（小于(10000-100)/2+100）的值。那我想要：最小值100，最大值10000，平均值9000的该如何解决？

拿10000-随机值不就是了

前面的你可以看不懂，但代码会运行吧，不多啰嗦了，上代码：

    public static void main(String[] args) {
        int min = 100;
        int max = 10000;
        int average = 1000;
        System.out.println(start(min, max, average));
    }

    /**
     * 开始计算区间
     *
     * @param min     最小随机数
     * @param max     最大随机数
     * @param average 平均值
     * @return 返回双曲函数的左区间的值
     */
    public static double start(double min, double max, double average) {
        double targetRatio = (average - min) / (max - min);
        System.out.println("-------------计算开始,最小值：" + min + "，最大值：" + max + "，平均值：" + average + "，目标比例：" + targetRatio + "---------------");
        if (targetRatio >= 1 || targetRatio <= 0) {
            throw new RuntimeException("你傻吗");
        }
        if (targetRatio > 0.5d) {
            double m = recursiveLeftInterval(0d, 1d, 1 - targetRatio);
            System.out.println("\n\n-------------计算结果---------------");
            System.out.println("函数y=" + max + "-(1/x-1)*(+" + max + "-" + min + ")/(1/" + m + "-1)" + "在区间[" + m + ",1]的平均值约：" + average);
            return m;
        } else if (targetRatio < 0.5d) {
            double m = recursiveLeftInterval(0d, 1d, targetRatio);
            System.out.println("\n\n-------------计算结果---------------");
            System.out.println("函数y=(1/x-1)*(+" + max + "-" + min + ")/(1/" + m + "-1)+" + min + "在区间[" + m + ",1]的平均值约：" + average);
            return m;
        } else {
            throw new RuntimeException("骚年小学数学不及格啊");
        }
    }

    /**
     * 请使用上面的start方法
     * 

     * 递归求y=1/x-1在区间[m,1]中m的值
     *
     * @param minM        m的最小值,第一次传0
     * @param maxM        m的最大值,第一次传1
     * @param targetRatio 目标比例必须<0.5,如果>0.5请反置
     * @return 返回左区间m的值
     */
    private static double recursiveLeftInterval(double minM, double maxM, double targetRatio) {
        //二分法m
        double currentM = (maxM + minM) / 2;

        //就是dx/(1-m)/(1/m-1)，简化了一下，dx=-ln(m)-(1-m)
        double currentRatio = currentM / (currentM - 1) / (currentM - 1) * (currentM - 1 - Math.log(currentM));
        System.out.println("当前m的范围[" + minM + "," + maxM + "]，当前m的值" + currentM + "]，当前比例" + currentRatio);

        //精度上限
        if (currentM == minM || currentM == maxM) {
            System.out.println("达到double精度上限，最终m的范围[" + minM + "," + maxM + "]，最终m的值" + currentM);
            return currentM;
        }

        if (currentRatio > targetRatio) {//在范围左边
            return recursiveLeftInterval(minM, currentM, targetRatio);
        } else if (currentRatio < targetRatio) {//在范围右边
            return recursiveLeftInterval(currentM, maxM, targetRatio);
        }
        System.out.println("计算比例刚好相等，最终m的范围[" + minM + "," + maxM + "]，最终m的值：" + currentM);
        return currentM;
    }

打印的最终结果：0.03569086434475005

也许你啥都没看懂，没关系，只要你能把上面的代码改成自己的最大值、最小值、平均值然后跑起来，得到m，任务就完成了

至此你可以把上面的代码都删掉了

真正使用：

    /**
     * 真正的使用是这样的
     */
    public static void example() {
        System.out.println("\n\n-------------举例最少50积分，最大5000积分，平均800积分---------------");
        int min = 50;
        int max = 5000;
        int average = 800;

//        double m= start(min,max,average);//大错特错，每次都计算多浪费性能
        //m是写死的，只需要算过一次保存下来就行了（若三个值有变动记得再算一遍）
        double m = 0.07977647130071558;

        double ratio = ((double) average - min) / (max - min);

        //随机m~1的数
        double random = Math.random() * (1d - m) + m;

        //+0.5表示四舍五入
        int integral;
        //这里的if是为了防止一些人比较笨，无脑复制导致公式用错
        if (ratio > 0.5) {
            //最小值100，最大值10000，平均值9000就会>0.5了。此时只需要拿最大值减去随机值就行了
            integral = (int) (max - (1 / random - 1) * (max - min) / (1 / m - 1) + 0.5);
        } else {
            //双曲线的平均值都是<0.5的
            integral = (int) ((1 / random - 1) * (max - min) / (1 / m - 1) + min + 0.5);
        }

        System.out.println("随机的一个积分" + integral);


        
        // 随机验证
        
        System.out.println("\n\n-------------随机验证统计区---------------");
        //验证循环次数
        int totalCount = 1000000;
        //积分总和
        double sum = 0;
        //统计随机出来的最大、最小积分
        int statisticalMax = 0, statisticalMin = Integer.MAX_VALUE;
        //统计每1/10的分布情况
        int[] statisticalDistributions = new int[11];//max也要占一个坑，所以是11，第11个就是max的数量

        for (int i = 0; i < totalCount; i++) {
            //随机m~1之间的数
            double random2 = Math.random() * (1 - m) + m;
            //+0.5表示四舍五入
            int integral2;
            if (ratio > 0.5) {
                integral2 = (int) (max - (1 / random2 - 1) * (max - min) / (1 / m - 1) + 0.5);
            } else {
                integral2 = (int) ((1 / random2 - 1) * (max - min) / (1 / m - 1) + min + 0.5);
            }
            sum += integral2;
            //最大最小值
            if (integral2 > statisticalMax) {
                statisticalMax = integral2;
            }
            if (integral2 < statisticalMin) {
                statisticalMin = integral2;
            }
            //统计
            int distributionsIndex = (integral2 - min) * 10 / (max - min);
            statisticalDistributions[distributionsIndex] += 1;
        }

        System.out.println("随机数平均值：" + sum / totalCount);
        System.out.println("随机数最大值：" + statisticalMax + "随机数最小值：" + statisticalMin);
        System.out.println("每1/10的数据量分布：" + Arrays.toString(statisticalDistributions));//第11个直接是max的数量
    }

现在就请尽情的挥洒吧。

其实真正的代码连5行都没有，但从无到有的逻辑真的够喝几天的了...