Java语言实现的有趣问题:你的斗地主能拿多少炸?

创业点子 阅读(558)

前锋JAVA发展学院我想昨天分享

最近很无聊,我想知道当我玩房东时我能得到多少炸弹(4张卡具有相同数量的点或国王)。但是,我的概率研究并不好,所以我想用统计数据来试试,我写了一个程序来模拟房东的许可过程

面向对象的卡

首先,根据OOP的想法,我将卡视为一个对象。点和颜色是它们的属性。为了处理国王的大小,我添加了Type属性。

公共类卡{

西装;

尺寸大小;

输入类型;

卡(西装套装,尺码){

This.suit=西装;

This.size=大小;

This.type=Type.Ordinary;

}

卡(类型类型){

如果(type.equals(Type.Ordinary)){

抛出新的RuntimeException;

}

This.type=类型;

}

}

我使用枚举类来表示所有三个属性,纯粹是因为它是面向对象的,那么它纯粹是

公共枚举大小{

P3(0),P4(1),P5(2),P6(3),P7(4),P8(5),P9(6),

P10(7),J(8),Q(9),K(10),A(11),P2(12);

Int序列;

大小(int序列){

This.sequence=序列;

}

}

大小表示点的大小,从小到大排序。添加序列属性的目的是为了便于统计期间的处理

Public enum Suit {

锹(4),心(3),俱乐部(2),钻石(1);

//权重

重量;

适合(int weight){

This.weight=体重;

}

}

西装套装,加重量属性作为尺码重量,房东颜色不是大小,但有些卡会有所不同,所以加上

公共枚举类型{

普通(0),LITTLE_JOKER(1),BIG_JOKER(2);

重量;

输入(int weight){

This.weight=体重;

}

}

型卡类型,主要用于特殊处理大小的王者,根据重量值,小王比小王

计算过程

首先抽象扑克牌的步骤,第一步:取出一副纸牌;第二步:随机播放(随机中断);第三步:交易;第四步:玩(计算是否有炸弹)我简化了许可方法并将其放入主程序中。其他步骤如下:

静态卡newCards {

//牌组由数组表示

卡片卡=新卡[54];

//cursor i

Int i=0;

//循环释放13种尺寸* 4种颜色=52

对于(大小点: Size.values){

For(Suit suit: Suit.values){

卡片[i ++]=新卡(套装,点);

}

}

//插入尺寸王

卡[52]=新卡(Type.LITTLE_JOKER);

卡[53]=新卡(Type.BIG_JOKER);

退卡;

}

静电卡随机播放(卡片卡){

随机随机=新随机; Int len=cards.length;

//复杂的O(n)

//遍历一副牌,随机挑选当前牌后面的牌(包括当前牌)并每次与当前牌交换。

//在完全随机的情况下,每张卡在每个位置的概率应该是相同的,有n个!例

For(int i=0; i len; i ++){

Int r=random.nextInt(len - i);

改变(i,r + i,卡片);

}

退卡;

}

//简单的交互式定位方法

静态空洞变化(int a,int b,Card cards){

卡片临时卡=[a];

卡并[a]=卡并[b];

卡并[b]=温度;

}

静态最终int DOUBLE_JOKER=3;

静态final int FULL_SUIT=10;

静态布尔值hasBoom(卡片卡){

//构造一个初始0的数组,其大小等于的大小

Int counter=new int [Size.values.length]; //初始化为0

//特殊处理尺寸王

Int weightOfJoker=0;

对于(卡片卡:卡){

//特殊处理尺寸王

如果(!card.type.equals(Type.Ordinary)){

weightOfJoker +=card.type.weight;

//当国王和体重的大小为3时,国王将会爆炸

如果(weightOfJoker==DOUBLE_JOKER){

返回true;

}

继续;

}

//使用点序列作为下标加上权重值,当它为10时,它将生成4张卡。

计数器[card.size.sequence] +=card.suit.weight;

如果(counter [card.size.sequence]==FULL_SUIT){

返回true;

}

}

返回false;

}

游戏的主要方法,计算每个房东和农民的概率

Public static void main(String args){

Long gameStart=System.currentTimeMillis;

Int gameTime=;

//Farmer的17张卡片柜台

Int nongHasBoom=0;

//Landlord 20卡计数器

Int diHasBoom=0;

//运行游戏

For(int i=0; i gameTime; i ++){

//获取新卡

扑克牌=新牌;

//洗牌

扑克=洗牌(扑克);

//在随机情况下处理,持续开发和子开发理论上不会影响卡的概率,简化

Card nong=Arrays.copyOf(扑克,17);

Card di=Arrays.copyOfRange(扑克,17,17 + 20);

nongHasBoom +=hasBoom(nong)? 1: 0;

diHasBoom +=hasBoom(di)? 1: 0;

}

Long gameEnd=System.currentTimeMillis;

System.out.println(String.format(房东炸弹概率%f,农民炸弹概率%f,diHasBoom * 1.0/gameTime,nongHasBoom * 0.1/gameTime));

System.out.println(String.format(runtime%f s,(gameEnd - gameStart)/1000.0));

}

运行一个程序,发现运行速度相当快,不管怎样,不到半秒的10万次,操作发现房东的三张卡上炸弹的概率是如此之大,可以增加几乎翻倍的几率。当然,程序是我随便写的。可能存在数据错误不严格的地方。如果你找到它,请斧头。其次,在枚举类的编写规范中,我偷了一些懒惰,而不是全部大写

收集报告投诉

最近很无聊,我想知道当我玩房东时我能得到多少炸弹(4张卡具有相同数量的点或国王)。但是,我的概率研究并不好,所以我想用统计数据来试试,我写了一个程序来模拟房东的许可过程

面向对象的卡

首先,根据OOP的想法,我将卡视为一个对象。点和颜色是它们的属性。为了处理国王的大小,我添加了Type属性。

公共类卡{

西装;

尺寸大小;

输入类型;

卡(西装套装,尺码){

This.suit=西装;

This.size=大小;

This.type=Type.Ordinary;

}

卡(类型类型){

如果(type.equals(Type.Ordinary)){

抛出新的RuntimeException;

}

This.type=类型;

}

}

我使用枚举类来表示所有三个属性,纯粹是因为它是面向对象的,那么它纯粹是

公共枚举大小{

P3(0),P4(1),P5(2),P6(3),P7(4),P8(5),P9(6),

P10(7),J(8),Q(9),K(10),A(11),P2(12);

Int序列;

大小(int序列){

This.sequence=序列;

}

}

大小表示点的大小,从小到大排序。添加序列属性的目的是为了便于统计期间的处理

Public enum Suit {

锹(4),心(3),俱乐部(2),钻石(1);

//权重重量;

适合(int weight){

This.weight=体重;

}

}

西装套装,加重量属性作为尺码重量,房东颜色不是大小,但有些卡会有所不同,所以加上

公共枚举类型{

普通(0),LITTLE_JOKER(1),BIG_JOKER(2);

重量;

输入(int weight){

This.weight=体重;

}

}

型卡类型,主要用于特殊处理大小的王者,根据重量值,小王比小王

计算过程

首先抽象扑克牌的步骤,第一步:取出一副纸牌;第二步:随机播放(随机中断);第三步:交易;第四步:玩(计算是否有炸弹)我简化了许可方法并将其放入主程序中。其他步骤如下:

静态卡newCards {

//牌组由数组表示

卡片卡=新卡[54];

//cursor i

Int i=0;

//循环释放13种尺寸* 4种颜色=52

对于(大小点: Size.values){For(Suit suit: Suit.values){

卡片[i ++]=新卡(套装,点);

}

}

//插入尺寸王

卡[52]=新卡(Type.LITTLE_JOKER);

卡[53]=新卡(Type.BIG_JOKER);

退卡;

}

静电卡随机播放(卡片卡){

随机随机=新随机;

Int len=cards.length;

//复杂的O(n)

//遍历一副牌,随机挑选当前牌后面的牌(包括当前牌)并每次与当前牌交换。

//在完全随机的情况下,每张卡在每个位置的概率应该是相同的,有n个!例

For(int i=0; i len; i ++){

Int r=random.nextInt(len - i);

改变(i,r + i,卡片);

}

退卡;

}

//简单的交互式定位方法

静态空洞变化(int a,int b,Card cards){

卡片临时卡=[a];

卡并[a]=卡并[b];

卡并[b]=温度;

}

静态最终int DOUBLE_JOKER=3;

静态final int FULL_SUIT=10;

静态布尔值hasBoom(卡片卡){

//构造一个初始0的数组,其大小等于的大小

Int counter=new int [Size.values.length]; //初始化为0

//特殊处理尺寸王

Int weightOfJoker=0;

对于(卡片卡:卡){

//特殊处理尺寸王

如果(!card.type.equals(Type.Ordinary)){

weightOfJoker +=card.type.weight;

//当国王和体重的大小为3时,国王将会爆炸

如果(weightOfJoker==DOUBLE_JOKER){

返回true;

}

继续;

} //使用点序列作为下标加上权重值,当它为10时,它将生成4张卡。

计数器[card.size.sequence] +=card.suit.weight;

如果(counter [card.size.sequence]==FULL_SUIT){

返回true;

}

}

返回false;

}

游戏的主要方法,计算每个房东和农民的概率

Public static void main(String args){

Long gameStart=System.currentTimeMillis;

Int gameTime=;

//Farmer的17张卡片柜台

Int nongHasBoom=0;

//Landlord 20卡计数器

Int diHasBoom=0;

//运行游戏

For(int i=0; i gameTime; i ++){

//获取新卡

扑克牌=新牌;

//洗牌

扑克=洗牌(扑克);

//在随机情况下处理,持续开发和子开发理论上不会影响卡的概率,简化

Card nong=Arrays.copyOf(扑克,17);

Card di=Arrays.copyOfRange(扑克,17,17 + 20);

nongHasBoom +=hasBoom(nong)? 1: 0;

diHasBoom +=hasBoom(di)? 1: 0;

}

Long gameEnd=System.currentTimeMillis;

System.out.println(String.format(房东炸弹概率%f,农民炸弹概率%f,diHasBoom * 1.0/gameTime,nongHasBoom * 0.1/gameTime));

System.out.println(String.format(runtime%f s,(gameEnd - gameStart)/1000.0));

}

运行一个程序,发现运行速度相当快,不管怎样,不到半秒的10万次,操作发现房东的三张卡上炸弹的概率是如此之大,可以增加几乎翻倍的概率。当然,程序是我随便写的。可能存在数据错误不严格的地方。如果你找到它,请斧头。其次,在枚举类的编写规范中,我偷了一些懒惰,而不是全部大写