那些年熬过的夜竟为了一个固定概率的抽奖

旧城等待， 2023-07-03 12:27 1阅读 0赞

### 文章目录 ###

*  前言
 *  思路
 *  show you the code
 *   *  处理结果
     *  修改库存
 *  总结

# 前言 #

今晚开完项目需求会，有个需求挺有意思，上次我在抽奖这一块扑街了，所以格外小心。今晚的需求会上又有相同的抽奖，但是是有一定概率的。so 开干！

# 思路 #

先根据每个奖项的概率进行初始化一个大概的int区间，然后随机填入对应奖项，接着就是随机产生这个区间大小里面的一个值，那到这个值所在数组的奖项就是抽到的值。  
接着可能还会有奖项的库存，所以加了一个库存map，每次都去减一，减到库存为0，见区间里面所有该奖项都剔除，接着抽，直到所有奖项都抽完，谢谢惠顾~

# show you the code #

import cn.hutool.core.util.ArrayUtil;
    import com.alibaba.fastjson.JSON;
    import org.springframework.util.StopWatch;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Random;
    
    public class LotteryTest {
    
        private static Map<Integer, Integer> map = new HashMap<>(3);
    
        /**
         * 统计map
         */
        private static Map<Integer, Integer> countMap = new HashMap<>(3);
    
        /**
         * 库存map
         */
        private static Map<Integer, Integer> stockMap = new HashMap<>(3);
    
        /**
         * 分别代表a,b,c
         */
        private static int[] s = {0, 1, 2};
    
        /**
         * 区间
         */
        private static int[] t = new int[10000];
    
        static {
    
            /*
              a奖品概率
             */
            double a = 0.3;
            /*
              a奖品对应数量
             */
            int aCount = (int) (t.length * a);
            /*
              b奖品概率
             */
            double b = 0.5;
            /*
              b奖品对应数量
             */
            int bCount = (int) (t.length * b);
            /*
              c奖品概率
             */
            double c = 0.2;
            /*
              c奖品对应数量
             */
            int cCount = (int) (t.length * c);
            //初始化奖品对应的数量以及库存
            map.put(0, aCount);
            map.put(1, bCount);
            map.put(2, cCount);
            countMap.put(0, 0);
            countMap.put(1, 0);
            countMap.put(2, 0);
            stockMap.put(0, 500);
            stockMap.put(1, 500);
            stockMap.put(2, 500);
        }
    	/**
         * 删除数组里面的相关匹配的所有值
         */
        private static int[] removeEle(int[] s, int element) {
            boolean isFinish = false;
            while (isFinish) {
                int index = ArrayUtil.indexOf(s, element);
                System.out.println(index);
                s = ArrayUtil.remove(s, index);
                if (index == -1) {
                    isFinish = true;
                }
            }
            return s;
        }
    
        /**
         * 根据概率初始化区间
         */
        public static void init() {
            Random random = new Random();
            int size = 3;
            for (int i = 0; i < t.length; i++) {
                int num = s[random.nextInt(size)];
                if (map.get(num) == 1) {
                    size--;
                    s = removeEle(s, num);
                }
                map.put(num, map.get(num) - 1);
                t[i] = num;
            }
        }
    
        public static void main(String[] args) {
            StopWatch watch = new StopWatch();
            watch.start("initData");
            init();
            watch.stop();
            System.out.println(JSON.toJSONString(t));
            watch.start("lottery");
            Random random = new Random();
            for (int i = 0; i < 1000; i++) {
                if (t.length == 0) {
                    System.out.println("谢谢惠顾");
                } else {
                    int num = t[random.nextInt(t.length)];
                    countMap.put(num, countMap.get(num) + 1);
                    System.out.println("中了" + t[random.nextInt(t.length)] + "等奖");
                    if (stockMap.get(num) == 1) {
                        t = removeEle(t, num);
                        //System.out.println(JSON.toJSONString(t));
                    }
                    stockMap.put(num, stockMap.get(num) - 1);
                }
            }
            watch.stop();
            System.out.println(watch.prettyPrint());
            System.out.println(JSON.toJSONString(countMap));
        }
    
    }

## 处理结果 ##

**库存充足情况下：**

StopWatch '': running time (millis) = 62
    -----------------------------------------
    ms     %     Task name
    -----------------------------------------
    00012  019%  initData
    00050  081%  lottery
    
    {0:306,1:500,2:194}

初始化是6ms,抽奖是10ms，还行。  
下面是奖项的累计抽到人数。

**库存不足情况下：**

谢谢惠顾
    谢谢惠顾
    StopWatch '': running time (millis) = 67
    -----------------------------------------
    ms     %     Task name
    -----------------------------------------
    00011  016%  initData
    00056  084%  lottery
    
    {0:100,1:20,2:80}

## 修改库存 ##

stockMap.put(0, 500);
            stockMap.put(1, 500);
            stockMap.put(2, 500);

# 总结 #

上面总体设计或者耗时都还行，但是放到分布式环境进去就会有问题，比如并发扣减库存，并发初始化区间等等，这个时候需要使用分布式锁以及一些思想去解决分布式环境的问题。