实现不同概率抽奖功能

最新推荐文章于 2022-05-02 16:02:55 发布
最新推荐文章于 2022-05-02 16:02:55 发布
阅读量1.2k 收藏
点赞数
分类专栏： c# 算法
c# 同时被 2 个专栏收录
391 篇文章 2 订阅
订阅专栏
算法
6 篇文章 0 订阅
订阅专栏

序号物品名称物品ID抽奖概率
1物品1P10.2
2物品2
P2
0.1
3物品3
P3
0.4
4物品4
P4
0.3
5物品5
P5
0.0
6物品6
P6
-0.1
7物品7
P7
0.008


  • VO类：Gift.java    具体对应就是上面表格里的内容
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class Gift {
     private int index;
     private String gitfId;
     private String giftName;
     private double probability;
 
     public Gift( int index, String gitfId, String giftName, double probability) {
         this .index = index;
         this .gitfId = gitfId;
         this .giftName = giftName;
         this .probability = probability;
     }
 
     public int getIndex() {
         return index;
     }
 
     public void setIndex( int index) {
         this .index = index;
     }
 
     public String getGitfId() {
         return gitfId;
     }
 
     public void setGitfId(String gitfId) {
         this .gitfId = gitfId;
     }
 
     public String getGiftName() {
         return giftName;
     }
 
     public void setGiftName(String giftName) {
         this .giftName = giftName;
     }
 
     public double getProbability() {
         return probability;
     }
 
     public void setProbability( double probability) {
         this .probability = probability;
     }
 
     @Override
     public String toString() {
         return "Gift [index=" + index + ", gitfId=" + gitfId + ", giftName=" + giftName + ", probability=" + probability + "]" ;
     }
 
}
  • Util类：LotteryUtil.java    真正的不同概率的抽奖工具类
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
/**
  * 不同概率抽奖工具包
  *
  * @author Shunli
  */
public class LotteryUtil {
     /**
      * 抽奖
      *
      * @param orignalRates
      *            原始的概率列表，保证顺序和实际物品对应
      * @return
      *         物品的索引
      */
     public static int lottery(List<Double> orignalRates) {
         if (orignalRates == null || orignalRates.isEmpty()) {
             return - 1 ;
         }
 
         int size = orignalRates.size();
 
         // 计算总概率，这样可以保证不一定总概率是1
         double sumRate = 0d;
         for ( double rate : orignalRates) {
             sumRate += rate;
         }
 
         // 计算每个物品在总概率的基础下的概率情况
         List<Double> sortOrignalRates = new ArrayList<Double>(size);
         Double tempSumRate = 0d;
         for ( double rate : orignalRates) {
             tempSumRate += rate;
             sortOrignalRates.add(tempSumRate / sumRate);
         }
 
         // 根据区块值来获取抽取到的物品索引
         double nextDouble = Math.random();
         sortOrignalRates.add(nextDouble);
         Collections.sort(sortOrignalRates);
 
         return sortOrignalRates.indexOf(nextDouble);
     }
}
  • Test类：Test.java
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
 
/**
  * 不同概率抽奖
  *
  * @author ShunLi
  */
public class LotteryTest {
     public static void main(String[] args) {
         List<Gift> gifts = new ArrayList<Gift>();
         // 序号==物品Id==物品名称==概率
         gifts.add( new Gift( 1 , "P1" , "物品1" , 0 .2d));
         gifts.add( new Gift( 2 , "P2" , "物品2" , 0 .2d));
         gifts.add( new Gift( 3 , "P3" , "物品3" , 0 .4d));
         gifts.add( new Gift( 4 , "P4" , "物品4" , 0 .3d));
         gifts.add( new Gift( 5 , "P5" , "物品5" , 0d));
         gifts.add( new Gift( 6 , "P6" , "物品6" , - 0 .1d));
         gifts.add( new Gift( 7 , "P7" , "物品7" , 0 .008d));
 
         List<Double> orignalRates = new ArrayList<Double>(gifts.size());
         for (Gift gift : gifts) {
             double probability = gift.getProbability();
             if (probability < 0 ) {
                 probability = 0 ;
             }
             orignalRates.add(probability);
         }
 
         // statistics
         Map<Integer, Integer> count = new HashMap<Integer, Integer>();
         double num = 1000000 ;
         for ( int i = 0 ; i < num; i++) {
             int orignalIndex = LotteryUtil.lottery(orignalRates);
 
             Integer value = count.get(orignalIndex);
             count.put(orignalIndex, value == null ? 1 : value + 1 );
         }
 
         for (Entry<Integer, Integer> entry : count.entrySet()) {
             System.out.println(gifts.get(entry.getKey()) + ", count=" + entry.getValue() + ", probability=" + entry.getValue() / num);
         }
     }
 
}



不同概率的抽奖原理很简单 
就是把0到1的区间分块，而分块的依据就是物品占整个的比重，再根据随机数种子来产生0-1中间的某个数，来判断这个数是落在哪个区间上，而对应的就是抽到了那个物品。随机数理论上是概率均等的，产生的每个数理论上也应该概率均等，那么相应的区间所含数的多少就体现了抽奖物品概率的不同。（p.s. 当然数目是数不清楚的，具体抽象话了点）

这个实例的数据可以说明 
1. 概率可以是负数和0，当然实际上中应该不会（p.s. 正常情况下可能真的有0，比如抽个iphone5，当然是抽不到的了，这个时候，构建礼物（List gifts）的时候最好就不要加这个进去），还有可以把负数的处理放到抽奖工具类(LotteryUtil)中； 
2. 所有礼物加起来的概率可以不是1，可以认为这里的概率是一个权重；


http://my.oschina.net/u/1026723/blog/271650


序号

物品名称物品ID抽奖概率
1物品1P10.2
2物品2
P2
0.1
3物品3
P3
0.4
4物品4
P4
0.3
5物品5
P5
0.0
6物品6
P6
-0.1
7物品7
P7
0.008


  • VO类：Gift.java    具体对应就是上面表格里的内容
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class Gift {
     private int index;
     private String gitfId;
     private String giftName;
     private double probability;
 
     public Gift( int index, String gitfId, String giftName, double probability) {
         this .index = index;
         this .gitfId = gitfId;
         this .giftName = giftName;
         this .probability = probability;
     }
 
     public int getIndex() {
         return index;
     }
 
     public void setIndex( int index) {
         this .index = index;
     }
 
     public String getGitfId() {
         return gitfId;
     }
 
     public void setGitfId(String gitfId) {
         this .gitfId = gitfId;
     }
 
     public String getGiftName() {
         return giftName;
     }
 
     public void setGiftName(String giftName) {
         this .giftName = giftName;
     }
 
     public double getProbability() {
         return probability;
     }
 
     public void setProbability( double probability) {
         this .probability = probability;
     }
 
     @Override
     public String toString() {
         return "Gift [index=" + index + ", gitfId=" + gitfId + ", giftName=" + giftName + ", probability=" + probability + "]" ;
     }
 
}
  • Util类：LotteryUtil.java    真正的不同概率的抽奖工具类
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
/**
  * 不同概率抽奖工具包
  *
  * @author Shunli
  */
public class LotteryUtil {
     /**
      * 抽奖
      *
      * @param orignalRates
      *            原始的概率列表，保证顺序和实际物品对应
      * @return
      *         物品的索引
      */
     public static int lottery(List<Double> orignalRates) {
         if (orignalRates == null || orignalRates.isEmpty()) {
             return - 1 ;
         }
 
         int size = orignalRates.size();
 
         // 计算总概率，这样可以保证不一定总概率是1
         double sumRate = 0d;
         for ( double rate : orignalRates) {
             sumRate += rate;
         }
 
         // 计算每个物品在总概率的基础下的概率情况
         List<Double> sortOrignalRates = new ArrayList<Double>(size);
         Double tempSumRate = 0d;
         for ( double rate : orignalRates) {
             tempSumRate += rate;
             sortOrignalRates.add(tempSumRate / sumRate);
         }
 
         // 根据区块值来获取抽取到的物品索引
         double nextDouble = Math.random();
         sortOrignalRates.add(nextDouble);
         Collections.sort(sortOrignalRates);
 
         return sortOrignalRates.indexOf(nextDouble);
     }
}
  • Test类：Test.java
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
 
/**
  * 不同概率抽奖
  *
  * @author ShunLi
  */
public class LotteryTest {
     public static void main(String[] args) {
         List<Gift> gifts = new ArrayList<Gift>();
         // 序号==物品Id==物品名称==概率
         gifts.add( new Gift( 1 , "P1" , "物品1" , 0 .2d));
         gifts.add( new Gift( 2 , "P2" , "物品2" , 0 .2d));
         gifts.add( new Gift( 3 , "P3" , "物品3" , 0 .4d));
         gifts.add( new Gift( 4 , "P4" , "物品4" , 0 .3d));
         gifts.add( new Gift( 5 , "P5" , "物品5" , 0d));
         gifts.add( new Gift( 6 , "P6" , "物品6" , - 0 .1d));
         gifts.add( new Gift( 7 , "P7" , "物品7" , 0 .008d));
 
         List<Double> orignalRates = new ArrayList<Double>(gifts.size());
         for (Gift gift : gifts) {
             double probability = gift.getProbability();
             if (probability < 0 ) {
                 probability = 0 ;
             }
             orignalRates.add(probability);
         }
 
         // statistics
         Map<Integer, Integer> count = new HashMap<Integer, Integer>();
         double num = 1000000 ;
         for ( int i = 0 ; i < num; i++) {
             int orignalIndex = LotteryUtil.lottery(orignalRates);
 
             Integer value = count.get(orignalIndex);
             count.put(orignalIndex, value == null ? 1 : value + 1 );
         }
 
         for (Entry<Integer, Integer> entry : count.entrySet()) {
             System.out.println(gifts.get(entry.getKey()) + ", count=" + entry.getValue() + ", probability=" + entry.getValue() / num);
         }
     }
 
}



不同概率的抽奖原理很简单 
就是把0到1的区间分块，而分块的依据就是物品占整个的比重，再根据随机数种子来产生0-1中间的某个数，来判断这个数是落在哪个区间上，而对应的就是抽到了那个物品。随机数理论上是概率均等的，产生的每个数理论上也应该概率均等，那么相应的区间所含数的多少就体现了抽奖物品概率的不同。（p.s. 当然数目是数不清楚的，具体抽象话了点）

这个实例的数据可以说明 
1. 概率可以是负数和0，当然实际上中应该不会（p.s. 正常情况下可能真的有0，比如抽个iphone5，当然是抽不到的了，这个时候，构建礼物（List gifts）的时候最好就不要加这个进去），还有可以把负数的处理放到抽奖工具类(LotteryUtil)中； 
2. 所有礼物加起来的概率可以不是1，可以认为这里的概率是一个权重；

序号物品名称物品ID抽奖概率
1物品1P10.2
2物品2
P2
0.1
3物品3
P3
0.4
4物品4
P4
0.3
5物品5
P5
0.0
6物品6
P6
-0.1
7物品7
P7
0.008


  • VO类：Gift.java    具体对应就是上面表格里的内容
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class Gift {
     private int index;
     private String gitfId;
     private String giftName;
     private double probability;
 
     public Gift( int index, String gitfId, String giftName, double probability) {
         this .index = index;
         this .gitfId = gitfId;
         this .giftName = giftName;
         this .probability = probability;
     }
 
     public int getIndex() {
         return index;
     }
 
     public void setIndex( int index) {
         this .index = index;
     }
 
     public String getGitfId() {
         return gitfId;
     }
 
     public void setGitfId(String gitfId) {
         this .gitfId = gitfId;
     }
 
     public String getGiftName() {
         return giftName;
     }
 
     public void setGiftName(String giftName) {
         this .giftName = giftName;
     }
 
     public double getProbability() {
         return probability;
     }
 
     public void setProbability( double probability) {
         this .probability = probability;
     }
 
     @Override
     public String toString() {
         return "Gift [index=" + index + ", gitfId=" + gitfId + ", giftName=" + giftName + ", probability=" + probability + "]" ;
     }
 
}
  • Util类：LotteryUtil.java    真正的不同概率的抽奖工具类
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
/**
  * 不同概率抽奖工具包
  *
  * @author Shunli
  */
public class LotteryUtil {
     /**
      * 抽奖
      *
      * @param orignalRates
      *            原始的概率列表，保证顺序和实际物品对应
      * @return
      *         物品的索引
      */
     public static int lottery(List<Double> orignalRates) {
         if (orignalRates == null || orignalRates.isEmpty()) {
             return - 1 ;
         }
 
         int size = orignalRates.size();
 
         // 计算总概率，这样可以保证不一定总概率是1
         double sumRate = 0d;
         for ( double rate : orignalRates) {
             sumRate += rate;
         }
 
         // 计算每个物品在总概率的基础下的概率情况
         List<Double> sortOrignalRates = new ArrayList<Double>(size);
         Double tempSumRate = 0d;
         for ( double rate : orignalRates) {
             tempSumRate += rate;
             sortOrignalRates.add(tempSumRate / sumRate);
         }
 
         // 根据区块值来获取抽取到的物品索引
         double nextDouble = Math.random();
         sortOrignalRates.add(nextDouble);
         Collections.sort(sortOrignalRates);
 
         return sortOrignalRates.indexOf(nextDouble);
     }
}
  • Test类：Test.java
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
 
/**
  * 不同概率抽奖
  *
  * @author ShunLi
  */
public class LotteryTest {
     public static void main(String[] args) {
         List<Gift> gifts = new ArrayList<Gift>();
         // 序号==物品Id==物品名称==概率
         gifts.add( new Gift( 1 , "P1" , "物品1" , 0 .2d));
         gifts.add( new Gift( 2 , "P2" , "物品2" , 0 .2d));
         gifts.add( new Gift( 3 , "P3" , "物品3" , 0 .4d));
         gifts.add( new Gift( 4 , "P4" , "物品4" , 0 .3d));
         gifts.add( new Gift( 5 , "P5" , "物品5" , 0d));
         gifts.add( new Gift( 6 , "P6" , "物品6" , - 0 .1d));
         gifts.add( new Gift( 7 , "P7" , "物品7" , 0 .008d));
 
         List<Double> orignalRates = new ArrayList<Double>(gifts.size());
         for (Gift gift : gifts) {
             double probability = gift.getProbability();
             if (probability < 0 ) {
                 probability = 0 ;
             }
             orignalRates.add(probability);
         }
 
         // statistics
         Map<Integer, Integer> count = new HashMap<Integer, Integer>();
         double num = 1000000 ;
         for ( int i = 0 ; i < num; i++) {
             int orignalIndex = LotteryUtil.lottery(orignalRates);
 
             Integer value = count.get(orignalIndex);
             count.put(orignalIndex, value == null ? 1 : value + 1 );
         }
 
         for (Entry<Integer, Integer> entry : count.entrySet()) {
             System.out.println(gifts.get(entry.getKey()) + ", count=" + entry.getValue() + ", probability=" + entry.getValue() / num);
         }
     }
 
}



不同概率的抽奖原理很简单 
就是把0到1的区间分块，而分块的依据就是物品占整个的比重，再根据随机数种子来产生0-1中间的某个数，来判断这个数是落在哪个区间上，而对应的就是抽到了那个物品。随机数理论上是概率均等的，产生的每个数理论上也应该概率均等，那么相应的区间所含数的多少就体现了抽奖物品概率的不同。（p.s. 当然数目是数不清楚的，具体抽象话了点）

这个实例的数据可以说明 
1. 概率可以是负数和0，当然实际上中应该不会（p.s. 正常情况下可能真的有0，比如抽个iphone5，当然是抽不到的了，这个时候，构建礼物（List gifts）的时候最好就不要加这个进去），还有可以把负数的处理放到抽奖工具类(LotteryUtil)中； 
2. 所有礼物加起来的概率可以不是1，可以认为这里的概率是一个权重；



序号物品名称物品ID抽奖概率
1物品1P10.2
2物品2
P2
0.1
3物品3
P3
0.4
4物品4
P4
0.3
5物品5
P5
0.0
6物品6
P6
-0.1
7物品7
P7
0.008


  • VO类：Gift.java    具体对应就是上面表格里的内容
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public class Gift {
     private int index;
     private String gitfId;
     private String giftName;
     private double probability;
 
     public Gift( int index, String gitfId, String giftName, double probability) {
         this .index = index;
         this .gitfId = gitfId;
         this .giftName = giftName;
         this .probability = probability;
     }
 
     public int getIndex() {
         return index;
     }
 
     public void setIndex( int index) {
         this .index = index;
     }
 
     public String getGitfId() {
         return gitfId;
     }
 
     public void setGitfId(String gitfId) {
         this .gitfId = gitfId;
     }
 
     public String getGiftName() {
         return giftName;
     }
 
     public void setGiftName(String giftName) {
         this .giftName = giftName;
     }
 
     public double getProbability() {
         return probability;
     }
 
     public void setProbability( double probability) {
         this .probability = probability;
     }
 
     @Override
     public String toString() {
         return "Gift [index=" + index + ", gitfId=" + gitfId + ", giftName=" + giftName + ", probability=" + probability + "]" ;
     }
 
}
  • Util类：LotteryUtil.java    真正的不同概率的抽奖工具类
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
/**
  * 不同概率抽奖工具包
  *
  * @author Shunli
  */
public class LotteryUtil {
     /**
      * 抽奖
      *
      * @param orignalRates
      *            原始的概率列表，保证顺序和实际物品对应
      * @return
      *         物品的索引
      */
     public static int lottery(List<Double> orignalRates) {
         if (orignalRates == null || orignalRates.isEmpty()) {
             return - 1 ;
         }
 
         int size = orignalRates.size();
 
         // 计算总概率，这样可以保证不一定总概率是1
         double sumRate = 0d;
         for ( double rate : orignalRates) {
             sumRate += rate;
         }
 
         // 计算每个物品在总概率的基础下的概率情况
         List<Double> sortOrignalRates = new ArrayList<Double>(size);
         Double tempSumRate = 0d;
         for ( double rate : orignalRates) {
             tempSumRate += rate;
             sortOrignalRates.add(tempSumRate / sumRate);
         }
 
         // 根据区块值来获取抽取到的物品索引
         double nextDouble = Math.random();
         sortOrignalRates.add(nextDouble);
         Collections.sort(sortOrignalRates);
 
         return sortOrignalRates.indexOf(nextDouble);
     }
}
  • Test类：Test.java
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
 
/**
  * 不同概率抽奖
  *
  * @author ShunLi
  */
public class LotteryTest {
     public static void main(String[] args) {
         List<Gift> gifts = new ArrayList<Gift>();
         // 序号==物品Id==物品名称==概率
         gifts.add( new Gift( 1 , "P1" , "物品1" , 0 .2d));
         gifts.add( new Gift( 2 , "P2" , "物品2" , 0 .2d));
         gifts.add( new Gift( 3 , "P3" , "物品3" , 0 .4d));
         gifts.add( new Gift( 4 , "P4" , "物品4" , 0 .3d));
         gifts.add( new Gift( 5 , "P5" , "物品5" , 0d));
         gifts.add( new Gift( 6 , "P6" , "物品6" , - 0 .1d));
         gifts.add( new Gift( 7 , "P7" , "物品7" , 0 .008d));
 
         List<Double> orignalRates = new ArrayList<Double>(gifts.size());
         for (Gift gift : gifts) {
             double probability = gift.getProbability();
             if (probability < 0 ) {
                 probability = 0 ;
             }
             orignalRates.add(probability);
         }
 
         // statistics
         Map<Integer, Integer> count = new HashMap<Integer, Integer>();
         double num = 1000000 ;
         for ( int i = 0 ; i < num; i++) {
             int orignalIndex = LotteryUtil.lottery(orignalRates);
 
             Integer value = count.get(orignalIndex);
             count.put(orignalIndex, value == null ? 1 : value + 1 );
         }
 
         for (Entry<Integer, Integer> entry : count.entrySet()) {
             System.out.println(gifts.get(entry.getKey()) + ", count=" + entry.getValue() + ", probability=" + entry.getValue() / num);
         }
     }
 
}



不同概率的抽奖原理很简单 
就是把0到1的区间分块，而分块的依据就是物品占整个的比重，再根据随机数种子来产生0-1中间的某个数，来判断这个数是落在哪个区间上，而对应的就是抽到了那个物品。随机数理论上是概率均等的，产生的每个数理论上也应该概率均等，那么相应的区间所含数的多少就体现了抽奖物品概率的不同。（p.s. 当然数目是数不清楚的，具体抽象话了点）

这个实例的数据可以说明 
1. 概率可以是负数和0，当然实际上中应该不会（p.s. 正常情况下可能真的有0，比如抽个iphone5，当然是抽不到的了，这个时候，构建礼物（List gifts）的时候最好就不要加这个进去），还有可以把负数的处理放到抽奖工具类(LotteryUtil)中； 
2. 所有礼物加起来的概率可以不是1，可以认为这里的概率是一个权重；

mituan1234567
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java抽奖设置中奖率_java抽奖程序,可设置不同奖品获得概率
weixin_30016961的博客
02-13 796
展开全部importjava.awt.EventQueue;importjava.awt.TextArea;importjava.awt.TextField;importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;importjava.util.Random;importjavax.swing.JBut...
JAVA实现抽奖大转盘摇一摇核心算法 亲测实用
qq_36529480的博客
12-02 1665
公司最近市场活动需求频繁更新 什么抽奖活动 大转盘 摇一摇 各种活动 活动类型各种各样但是都是通过概率去算出来是否中将废话不多说 新手上路 大神勿喷 实体类 public class AnniversaryPrizePool { //序号 private int index; //中奖概率 private BigDecimal winningProbabi...
中奖概率工具类
weixin_43298522的博客
04-23 470
数据库表 CREATE TABLE `t_lottery_award` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `type` int(11) DEFAULT NULL COMMENT '1、红包，2、现金，3、实物，4、其他， 5、积分', `money` decimal(10,0) DEFAULT NULL COMMENT '奖品金额...
java 抽奖算法_Java抽奖概率算法 - hejunbinlan的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_26820341的博客
02-12 275
摘要：序号 奖品名称 奖品编号 抽到的概率 1 再来一次 P1 0.2 2 本站VIP一年 P2 0.1 3 谢谢参与 P3 0.4 4 50金币 P4 0.3 5 Iphone 6 P5 0.0 6 Ipad Air2 P6 -0.序号奖品名称奖品编号抽到的概率1再来一次P10.22本站VIP一年P20.13谢谢参与P30.4450金币P40.35Iphone 6P50.06Ipad Air2...
不同概率的抽奖
weixin_30301183的博客
10-18 244
今天为大家写个小程序。 工作中有遇到一些抽奖的活动，但是你懂得，抽奖物品的概率肯定不是一样，你会发现好的东西很难抽到，经常抽到一些垃圾的东西，嘿嘿，这就是本文要说的，我们要控制抽奖物品的概率。还有顺便说一句，网上这种小程序几乎没有，很多都是等概率的抽奖balabala… 需求很简单，为了更加形象，这里我们列一个表格来显示我们抽奖的物品和对应的概率（没有边框，大家凑合着看看吧，不想改造Octop...
微信小程序实现活动转盘抽奖功能
最新发布
07-13
在本案例中，我们讨论的是如何利用微信小程序实现一个活动转盘抽奖功能。 首先，我们要了解抽奖转盘的基本原理。抽奖转盘通常由多个扇区组成，每个扇区代表不同的奖项。用户点击开始抽奖按钮后，转盘会进行动画旋转...
PHP实现活动人选抽奖功能
12-19
在本文中，我们将探讨如何使用PHP来实现一个简单的活动人选抽奖功能。这个功能的主要目标是随机抽取一定数量的参与者，并确保每个人不会重复被选中。下面我们将深入解析给出的示例代码并解释其中的关键知识点。 ...
jquery实现转盘抽奖功能
10-20
在本文中，我们将探讨如何使用jQuery和jqueryRotate插件实现一个转盘抽奖功能。首先，我们需要了解jQuery，它是一个广泛使用的JavaScript库，简化了DOM操作、事件处理、动画和Ajax交互。而jqueryRotate插件是专门...
lottery:使用redis实现抽奖功能
03-27
在本场景中，我们将探讨如何使用Redis这一高效、内存数据存储系统来实现一个抽奖功能，特别关注Java开发环境下的应用。Redis因其快速的读写速度和丰富的数据结构，非常适合用于构建这种实时性强、并发量大的抽奖系统...
C# MVC模式下商品抽奖功能实现
09-02
在C# MVC模式下实现商品抽奖功能，首先要理解MVC（Model-View-Controller）架构。MVC是一种软件设计模式，用于将业务逻辑、数据处理和用户界面分离，提高代码的可维护性和可扩展性。在C#的ASP.NET框架中，MVC模式常...
常见的抽奖-根据指定概率抽奖（改进）
12-25
原文：http://blog.csdn.net/yysyangyangyangshan/article/details/12063343
常见的抽奖-根据指定概率抽奖（简单的）
11-25
原文：http://blog.csdn.net/yysyangyangyangshan/article/details/12029955
java抽奖概率抽奖
letterss的博客
05-02 3934
java实现概率抽奖
4类抽奖算法总结
热门推荐
guolalala的博客
03-24 1万+
第一类是常见的有等级的抽奖活动，如一等、二等、三等奖等等 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 // 分别为一、二、三、四等将的奖品数
抽奖活动不同概率实现
weixin_56772904的博客
11-03 562
说道抽奖活动，首先肯定会想到Random的使用，在整数和小数之中取随机数需要注意的是nextInt()和nextDouble(),前者是有参函数，后者是无参函数（如下）： int random = new Random().nextInt(10); double randomIndex = new Random().nextDouble(); 前者表示从0-10之间取任意随机数；后者表示在0-1之间取任意小数，如果需要取得指定范围内小数，可进行如下操作： double randomIndex = new
android 实现盲盒抽奖
06-07
1. 确定获奖概率：在盲盒抽奖中，不同奖品的中奖概率是不一样的，因此我们需要设定不同奖项的中奖概率并保存在服务器端，应用程序可以从服务器获取这些信息。 2. 抽奖规则：我们需要确定每次抽奖多少次以及每次抽奖...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值