昨天写了一篇利用Java程序统计彩票双色球中一等奖究竟有多难
今天突然来了兴趣想利用java程序分析分析福彩的3D，虽然没有买过这种彩票，但冲着作为一个程序猿对需求的敏感性，我决定试一哈
首先先分析了3D投注相关的规则
---------------------------
第二章 投 注
第六条 3D是指以三个号码排列或组合为一注进行单式投注，投注号码由000-999组成，三个位置从左至右分别为“百位”、“十位”、“个位”，一组三个号码的排列或组合称为一注。每注金额人民币2元。购买者可对其选定的投注号码进行多倍投注，投注倍数范围为2-99倍。单张彩票的投注金额最高不得超过20000元。
第七条 投注者可在福彩销售机构设置的销售网点投注。投注号码经投注机打印出兑奖凭证，交购买者保存，此兑奖凭证即为3D彩票。
第八条 3D根据投注号码的排列或组合分为“单选”、“组选”、“1D”、“2D”、“通选”、“和数”、“包选”、“猜大小”、“猜1D”、“猜2D”、“猜三同”、“拖拉机”、“猜奇偶”等投注方式，具体规定如下：
（一）单选投注：是指对三个号码以唯一的排列方式进行投注。
（二）组选投注：是指将三个号码的所有排列方式作为一注投注号码进行投注。如果一注组选的三个号码中有两个号码相同，则包括三种不同的排列方式，称为“组选3”；如果一注组选的三个号码各不相同，则包括六种不同的排列方式，称为“组选6”。
（三）1D投注：是指对百位、十位或个位中某一特定位置上的号码进行投注。
（四）猜1D投注：是指对百位、十位或个位中任意一个位置上的号码进行投注。
（五）2D投注：是指对百位和十位、十位和个位或百位和个位号码，以唯一的排列方式进行投注。
（六）猜2D投注：是指对百位、十位或个位中任意两个位置上的号码进行投注。
（七）通选投注：是指对三个号码以唯一的排列方式进行投注。
（八）和数投注：是指对三个号码相加之和进行投注。
（九）包选投注：是指同时用单选和组选的方式对三个号码进行投注。如果三个号码中有两个号码相同，则包括三种不同的排列方式，称为“包选3”；如果三个号码各不相同，则包括六种不同的排列方式，称为“包选6”。
（十）猜大小投注：是指对三个号码相加之和的大、小性质进行投注。其中，三个号码相加之和在19（含）至27（含）之间时为大，在0（含）至8（含）之间时为小。
（十一）猜三同投注：是指对全部三个相同的号码进行投注。
（十二）拖拉机投注：是指对全部以升序或降序连续排列的号码进行投注（890、098、901、109除外）。
（十三）猜奇偶投注：是指对全部三个号码的奇数、偶数性质进行投注。其中，1、3、5、7、9为奇，0、2、4、6、8为偶。
---------------------------确实简单，只有3个球 ，每个球可选0-9 ，只是投注方式比较多而已
目前福彩的奖项是 直选 组三 组六
直选是单选投注方式，只要投注号码和中奖号码数字与位置都一致，即为中奖
例子：中奖号码123 中出为 123
组三是组选投注方式，就是包括对子，不限位置，3个数中有两个一样的数字
例子：中奖号码122 中出为 122 212 221
组六是组选投注方式，就是3个数字都不相同，不限位置
例子：中奖号码123 中出为 123 132 213 231 312 321
好了开干，先从第一种最简单的方式单选投注开始吧
单选投注
首先是有一个得到一个0-9之间的随机数字方法
然后执行3次上面的方法，挨个得到三个号码
package com.data.cp;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CP3DTest {
private static Random rand = new Random();
public static void main(String[] args) {
//2020-249期 本期销售 54856806 共27428403注3d彩票
int cpNum = 27428403;
String cpStr = "7-0-4";
Long startTime = System.currentTimeMillis();
//直选 多线程处理
int luckyNum = singleBettingFunc1(cpStr,cpNum);
System.out.println("3D中奖号码" + cpStr + " , 模拟"+ cpNum + "注彩票（直选）预计中奖奖数量 ：" + luckyNum);
Long endTime = System.currentTimeMillis();
System.out.println("用时：" + (endTime - startTime + "毫秒"));
}
private static int singleBettingFunc1(String cpStr, int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = singleBettingCountFunc(cpStr,taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int singleBettingCountFunc(String cpStr, Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dSingleStr();
if(cpTempStr.equals(cpStr)) {
luckyNum++;
}
}
return luckyNum;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
private static List<Integer> digits(int cpNum, int countDownLatchNum) {
List<Integer> digitNums = new CopyOnWriteArrayList<Integer>();
if(cpNum % countDownLatchNum > 0) {
countDownLatchNum = countDownLatchNum-1;
}
int spl = cpNum / countDownLatchNum;
for (int i = 0; i < countDownLatchNum; i++) {
digitNums.add(spl);
}
if(cpNum % countDownLatchNum > 0) {
digitNums.add(cpNum % countDownLatchNum);
}
return digitNums;
}
private static String getCp3dSingleStr() {
String cpStr = "";
int spl = 0;
List<Integer> cp3dSingle = getCp3dNums();
for (Integer num : cp3dSingle) {
cpStr += num;
if(spl < 2) {
cpStr += "-";
}
spl++;
}
return cpStr;
}
private static List<Integer> getCp3dNums() {
List<Integer> nums = new ArrayList<Integer>();
for (int i = 1; i <= 3; i++) {
nums.add(rand.nextInt(10));
}
return nums;
}
}
跑一下试试
组三投注
组三摇号与直选不一样的地方在于三个数中有两个要相同，同时在计算是否中奖的方法上有所变动
package com.data.cp;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CP3DTest {
private static Random rand = new Random();
public static void main(String[] args) {
//2020-249期 本期销售 54856806 共27428403注3d彩票
int cpNum = 27428403;
String cpStr = "7-4-4";
Long startTime = System.currentTimeMillis();
//直选 多线程处理
//int luckyNum = singleBettingFunc1(cpStr,cpNum);
//组3 多线程处理
int luckyNum = group3BettingFunc1(cpStr,cpNum);
System.out.println("3D中奖号码" + cpStr + " , 模拟"+ cpNum + "注彩票（组3）预计中奖奖数量 ：" + luckyNum);
Long endTime = System.currentTimeMillis();
System.out.println("用时：" + (endTime - startTime + "毫秒"));
}
private static int group3BettingFunc1(String cpStr, int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = group3BettingCountFunc(cpStr,taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int group3BettingCountFunc(String cpStr, Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dStr(getCp3dGroup3Nums());
if(isGroup3Num(cpStr,cpTempStr)) {
luckyNum++;
}
}
return luckyNum;
}
/**
* a-b-b == true > a-b-b b-a-b b-b-a
* @param cpStr
* @param cpTempStr
* @return
*/
private boolean isGroup3Num(String cpStr, String cpTempStr) {
if(cpStr.equals(cpTempStr)) {
return true;
}
String[] split = cpTempStr.split("-");
String bab = split[1] + "-" + split[0] + "-" + split[2];
if(cpStr.equals(bab)) {
return true;
}
String bba = split[1] + "-" + split[2] + "-" + split[0];
if(cpStr.equals(bba)) {
return true;
}
return false;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
private static int singleBettingFunc1(String cpStr, int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = singleBettingCountFunc(cpStr,taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int singleBettingCountFunc(String cpStr, Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dSingleStr();
if(cpTempStr.equals(cpStr)) {
luckyNum++;
}
}
return luckyNum;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
private static List<Integer> digits(int cpNum, int countDownLatchNum) {
List<Integer> digitNums = new CopyOnWriteArrayList<Integer>();
if(cpNum % countDownLatchNum > 0) {
countDownLatchNum = countDownLatchNum-1;
}
int spl = cpNum / countDownLatchNum;
for (int i = 0; i < countDownLatchNum; i++) {
digitNums.add(spl);
}
if(cpNum % countDownLatchNum > 0) {
digitNums.add(cpNum % countDownLatchNum);
}
return digitNums;
}
private static String getCp3dSingleStr() {
List<Integer> cp3dSingle = getCp3dSingleNums();
return getCp3dStr(cp3dSingle);
}
private static String getCp3dStr(List<Integer> cp3dSingle) {
String cpStr = "";
int spl = 0;
for (Integer num : cp3dSingle) {
cpStr += num;
if(spl < 2) {
cpStr += "-";
}
spl++;
}
return cpStr;
}
private static List<Integer> getCp3dGroup3Nums() {
List<Integer> nums = new ArrayList<Integer>();
nums.add(rand.nextInt(10));
int num = rand.nextInt(10);
nums.add(num);
nums.add(num);
return nums;
}
private static List<Integer> getCp3dSingleNums() {
return getCp3dNums();
}
private static List<Integer> getCp3dNums() {
List<Integer> nums = new ArrayList<Integer>();
for (int i = 1; i <= 3; i++) {
nums.add(rand.nextInt(10));
}
return nums;
}
}
组六投注
组六摇号与直选一样，不同的地方在于三个数中都不相同，同时在计算是否中奖的方法上有所变动
package com.data.cp;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CP3DTest {
private static Random rand = new Random();
public static void main(String[] args) {
//2020-249期 本期销售 54856806 共27428403注3d彩票
int cpNum = 27428403;
String cpStr = "1-2-3";
Long startTime = System.currentTimeMillis();
//直选 多线程处理
//int luckyNum = singleBettingFunc1(cpStr,cpNum);
//组3 多线程处理
//int luckyNum = group3BettingFunc1(cpStr,cpNum);
//组6 多线程处理
int luckyNum = group6BettingFunc1(cpStr,cpNum);
System.out.println("3D中奖号码" + cpStr + " , 模拟"+ cpNum + "注彩票（组6）预计中奖奖数量 ：" + luckyNum);
Long endTime = System.currentTimeMillis();
System.out.println("用时：" + (endTime - startTime + "毫秒"));
}
private static int group6BettingFunc1(String cpStr, int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = group6BettingCountFunc(cpStr,taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int group6BettingCountFunc(String cpStr, Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dStr(getCp3dGroup6Nums());
if(isGroup6Num(cpStr,cpTempStr)) {
luckyNum++;
}
}
return luckyNum;
}
/**
* a-b-c == true > a-b-c a-c-b b-a-c b-c-a c-a-b c-b-a
* @param cpStr
* @param cpTempStr
* @return
*/
private boolean isGroup6Num(String cpStr, String cpTempStr) {
if(cpStr.equals(cpTempStr)) {
return true;
}
String[] split = cpTempStr.split("-");
String acb = split[0] + "-" + split[2] + "-" + split[1];
if(cpStr.equals(acb)) {
return true;
}
String bac = split[1] + "-" + split[0] + "-" + split[2];
if(cpStr.equals(bac)) {
return true;
}
String bca = split[1] + "-" + split[2] + "-" + split[0];
if(cpStr.equals(bca)) {
return true;
}
String cab = split[2] + "-" + split[0] + "-" + split[1];
if(cpStr.equals(cab)) {
return true;
}
String cba = split[2] + "-" + split[1] + "-" + split[0];
if(cpStr.equals(cba)) {
return true;
}
return false;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
private static int group3BettingFunc1(String cpStr, int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = group3BettingCountFunc(cpStr,taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int group3BettingCountFunc(String cpStr, Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dStr(getCp3dGroup3Nums());
if(isGroup3Num(cpStr,cpTempStr)) {
luckyNum++;
}
}
return luckyNum;
}
/**
* a-b-b == true > a-b-b b-a-b b-b-a
* @param cpStr
* @param cpTempStr
* @return
*/
private boolean isGroup3Num(String cpStr, String cpTempStr) {
if(cpStr.equals(cpTempStr)) {
return true;
}
String[] split = cpTempStr.split("-");
String bab = split[1] + "-" + split[0] + "-" + split[2];
if(cpStr.equals(bab)) {
return true;
}
String bba = split[1] + "-" + split[2] + "-" + split[0];
if(cpStr.equals(bba)) {
return true;
}
return false;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
private static int singleBettingFunc1(String cpStr, int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = singleBettingCountFunc(cpStr,taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int singleBettingCountFunc(String cpStr, Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dSingleStr();
if(cpTempStr.equals(cpStr)) {
luckyNum++;
}
}
return luckyNum;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
private static List<Integer> digits(int cpNum, int countDownLatchNum) {
List<Integer> digitNums = new CopyOnWriteArrayList<Integer>();
if(cpNum % countDownLatchNum > 0) {
countDownLatchNum = countDownLatchNum-1;
}
int spl = cpNum / countDownLatchNum;
for (int i = 0; i < countDownLatchNum; i++) {
digitNums.add(spl);
}
if(cpNum % countDownLatchNum > 0) {
digitNums.add(cpNum % countDownLatchNum);
}
return digitNums;
}
private static String getCp3dSingleStr() {
List<Integer> cp3dSingle = getCp3dSingleNums();
return getCp3dStr(cp3dSingle);
}
private static String getCp3dStr(List<Integer> cp3dSingle) {
String cpStr = "";
int spl = 0;
for (Integer num : cp3dSingle) {
cpStr += num;
if(spl < 2) {
cpStr += "-";
}
spl++;
}
return cpStr;
}
private static List<Integer> getCp3dGroup3Nums() {
List<Integer> nums = new ArrayList<Integer>();
nums.add(rand.nextInt(10));
int num = rand.nextInt(10);
nums.add(num);
nums.add(num);
return nums;
}
private static List<Integer> getCp3dGroup6Nums(){
List<Integer> tempList = new ArrayList<Integer>();
for (int i=0; i<=9; i++) {
tempList.add(i);
}
List<Integer> nums = new ArrayList<Integer>();
for (int i=1; i<=3; i++) {
int randNum = rand.nextInt(tempList.size());
nums.add(tempList.get(randNum));
tempList.remove(randNum);
}
return nums;
}
private static List<Integer> getCp3dSingleNums() {
return getCp3dNums();
}
private static List<Integer> getCp3dNums() {
List<Integer> nums = new ArrayList<Integer>();
for (int i = 1; i <= 3; i++) {
nums.add(rand.nextInt(10));
}
return nums;
}
}
分析
对比上面的三种投注方式,随机得出来的中奖结果还是蛮诧异的
中奖数量 组三 > 组六 > 直选 而且组三与组六中奖数量几乎是直选10倍左右
但细想了下我这块的中奖号码是固定的，实际摇奖号码是随机的产生导致的
所以综合还要分析下组三与组六的出现的概率
组三出现的概率
private static int group3CountFunc1(int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = group3CountFunc(taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int group3CountFunc(Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dStr(getCp3dNums());
if(isGroup3Num(cpTempStr)) {
luckyNum++;
}
}
return luckyNum;
}
/**
* a-b-b
* @param cpStr
* @return
*/
private boolean isGroup3Num(String cpStr) {
String[] split = cpStr.split("-");
Map<String,Object> temp = new HashMap<String,Object>();
for (int i=0 ; i<split.length; i++) {
temp.put(split[i], i);
}
if(temp.size()==2) {
return true;
}
return false;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
}
取平均值计算后 组3的出现的概率约为 0.27
组六出现的概率
private static int group6CountFunc1(int cpNum) {
int luckyNum = 0;
int countDownLatchNum = 1000;//线程数
List<Integer> digits = digits(cpNum,countDownLatchNum);
List<Integer> list = new CopyOnWriteArrayList<Integer>();//存放返回结果
CountDownLatch countDownLatch = new CountDownLatch(countDownLatchNum);
ExecutorService executorService = Executors.newFixedThreadPool(countDownLatchNum);
for (int i = 0; i < countDownLatchNum; i++) {
Runnable runnable = new Runnable(){
@Override
public void run() {
try {
String name = Thread.currentThread().getName();
String[] split = name.split("-");
Integer threadId = Integer.parseInt(split[split.length-1]) - 1;
Integer taskNum = digits.get(threadId);
System.out.println("线程name:" + name + " \t执行任务数量：" + taskNum);
int luckyNumThread = group6CountFunc(taskNum);
//System.out.println("线程name:" + name + " \t执行完毕结果：" + cpOneNumRunnable);
list.add(luckyNumThread);
countDownLatch.countDown();
} catch (Exception e) {
e.printStackTrace();
}
}
private int group6CountFunc(Integer taskNum) {
int luckyNum = 0;
String cpTempStr = "";
for (int i=1; i<=taskNum; i++) {
cpTempStr = getCp3dStr(getCp3dNums());
if(isGroup6Num(cpTempStr)) {
luckyNum++;
}
}
return luckyNum;
}
/**
* a-b-c
* @param cpStr
* @return
*/
private boolean isGroup6Num(String cpStr) {
String[] split = cpStr.split("-");
Map<String,Object> temp = new HashMap<String,Object>();
for (int i=0 ; i<split.length; i++) {
temp.put(split[i], i);
}
if(temp.size()==3) {
return true;
}
return false;
}
};
executorService.execute(runnable);
}
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
executorService.shutdown();
for (Integer result : list) {
luckyNum += result;
}
return luckyNum;
} 
取平均值计算后 组6的出现的概率约为 0.72
在对比下面的奖金图 组三单注奖金是组六2倍 但在出现概率上却不是如此 所以如果我要买的话还是会去买组六
再来看直选的概率
大约是千分之一吧，概率虽然比组三和组六小了很多，但比起双色球还是杠杠滴，所以还是值得一试的，毕竟生活不易~~
本文就先分析到这里了， 仓促成文不当之处，请各位读者批评指正！
扫一扫
4931
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
