收藏
下载资源下载资源 加入VIP,免费下载

扑克牌生成与洗牌程序.docx

上传人：b****3 文档编号：4632143 上传时间：2022-12-07 格式：DOCX 页数：20 大小：46.10KB
下载 相关 举报
扑克牌生成与洗牌程序.docx_第1页
第1页 / 共20页
扑克牌生成与洗牌程序.docx_第2页
第2页 / 共20页
扑克牌生成与洗牌程序.docx_第3页
第3页 / 共20页
扑克牌生成与洗牌程序.docx_第4页
第4页 / 共20页
扑克牌生成与洗牌程序.docx_第5页
第5页 / 共20页
点击查看更多>>
下载资源
资源描述

扑克牌生成与洗牌程序.docx

《扑克牌生成与洗牌程序.docx》由会员分享，可在线阅读，更多相关《扑克牌生成与洗牌程序.docx（20页珍藏版）》请在冰豆网上搜索。

扑克牌生成与洗牌程序.docx

扑克牌生成与洗牌程序

扑克牌生成与洗牌程序

使用JAVA编写以下程序：

1、请定义一个名为Card的扑克牌类，该类有两个private访问权限的字符串变量face和suit；分别描述一张牌的牌面值（如：

A、K、Q、J、10、9、……3、2等）和花色（如：

“黑桃”、“红桃”、“梅花”、“方块”）；定义Card类中的public访问权限的构造方法，为类中的变量赋值；定义protected访问权限的方法getFace（），得到扑克牌的牌面值；定义protected访问权限的方法getSuit（），得到扑克牌的花色；定义方法toString（），返回表示扑克牌的花色和牌面值字符串（如“红桃A”、“梅花10”等）。

2、若应用程序的main方法中，定义字符串数组f和s；分别表示扑克牌的牌面值和花色；定义52个元素的Card类型数组deck，用来存放4个花色的52张牌。

如下所示。

Stringf[]={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

Strings[]={"黑桃","红桃","梅花","方块"};

Carddeck=newCard[52]；

（1）使用Card类的构造方法给deck数组的52张牌赋值，要求数组中先存放黑桃花色的A、2、3、……、K；然后是红桃花色的A、2、3、……、K；梅花花色的A、2、3、……、K；方块花色的A、2、3、……、K。

请写出实现上述功能的程序段。

（2）请编写模拟洗牌的完整程序，即把数组deck中的扑克牌随机打乱存放顺序。

原题如下：

引用内容

privateStringface;//A,K,Q,J,10,...2

privateStringsuit;//Spade,Heart,Club,Diamond

publicCard（Stringsuit,Stringface）{this.face=face;this.suit=suit;}

protectedStringgetFace（）{returnface;}

protectedStringgetSuit（）{returnsuit;}

publicStringtoString（）{returnsuit+""+face;}

解题，完成程序解：

程序代码

packagepoker;

publicclassCard{privateStringface;//A,K,Q,J,10,...2

privateStringsuit;//Spade,Heart,Club,Diamond

publicCard（Stringsuit,Stringface）{this.face=face;this.suit=suit;}

protectedStringgetFace（）{returnface;}

protectedStringgetSuit（）{returnsuit;}

publicStringtoString（）{returnsuit+""+face;}

publicstaticvoidshuffle（Card[]deck,intstartIndex,intsize,intsplitIndex）{//shuffle洗牌System.out.println（"startIndex:

"+startIndex）;

if（splitIndex*2>size）{//ifrandis30Card.swap（deck,startIndex,splitIndex,size-splitIndex）;//[52]、0、30、22

shuffle（deck,size-splitIndex,splitIndex,size-splitIndex）;//[52]、22、30、22}

elseif（splitIndex*2

Card.swap（deck,startIndex,size-splitIndex,splitIndex）;//[52]、0、42、10

shuffle（deck,startIndex,size-splitIndex,splitIndex）;//[52]、0、42、10}

else{Card.swap（deck,startIndex,splitIndex,splitIndex）;

}

}

publicstaticvoidswap（Card[]deck,intsrcIndex,intdstIndex,intsize）{//交换

//SRC是在本位置显示：

source的缩写，源的意思HREF是点击后连接的目标：

HyperlinkReference，超链接引用

Stringface="";

Stringsuit="";

for（inti=0;i

{face=deck[srcIndex+i].face;

suit=deck[srcIndex+i].suit;

deck[srcIndex+i].face=deck[dstIndex+i].face;

deck[srcIndex+i].suit=deck[dstIndex+i].suit;

deck[dstIndex+i].face=face;

deck[dstIndex+i].suit=suit;

}

}

/***@paramargs*/

publicstaticvoidmain（String[]args）{//第一问解答

Card[]deck=newCard[52];

Stringf[]={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

Strings[]={"Spade","Heart","Club","Diamond"};

for（inti=0;i

{

for（intj=0;j

deck[i*13+j]=newCard（s[i],f[j]）;//依次存入数组之中，每13张一回合}

}//第二问解答

intrnd=0;

intnumOfShuffle=10;

for（inti=0;i

//Math.random（）返回大于或等于0.0但小于1.0的伪随机double值。

Card.shuffle（deck,0,deck.length,rnd）;}//Test

/*

for（inti=0;i

{

System.out.println（deck[i]）;

}*/

}

}

PS：

函数shuffle是模拟洗牌的过程，这里的算法比较粗燥，随机产生一个52以内数字n，把牌分为两份，1..n-1,和n-52,然后把两份牌交换一下顺序，这里做了十次切牌。

shuffle是一个递归函数，startIndex表示切牌的开始序号，splitIndex表示切牌的序号，即上面的ngetXXX是用来得到牌的花色和数字，第二问用不到

本文来自CSDN博客，转载请标明出处：

publicclassDeckOfCardsextendsApplet{

privateCarddeck[];

privateintcurrentCard;

privateButtondealButton,shuffleButton;

privateTextFielddisplayCard;

publicvoidinit（）{

Stringfaces[]={"Ace","Deuce","Three","Four","Five","Six","Seven",

"Eight","Nine","Ten","Jack","Queen","King"};

Stringsuits[]={"Hearts","Diamonds","Clubs","Spades"};

deck=newCard[52];

currentCard=-1;

for（inti=0;i

deck[i]=newCard（faces[i%13],suits[i/13]）;

dealButton=newButton（"Dealcard"）;

shuffleButton=newButton（"shufflecards"）;

displayCard=newTextField（20）;

displayCard.setEditable（false）;

add（dealButton）;

add（shuffleButton）;

add（displayCard）;

}

publicbooleanaction（Eventevent,Objectobject）{

if（event.target==dealButton）{

Carddealt=dealCard（）;

if（dealt!

=null）{

displayCard.setText（dealt.toString（））;

showStatus（"Card#:

"+currentCard）;

}

else{

displayCard.setText（"NOMORECARDSTODEAL!

"）;

showStatus（"Shufflecardstocontinue!

"）;

}

}

elseif（event.target==shuffleButton）{

displayCard.setText（"SHUFFLECARDS...."）;

showStatus（""）;

shuffle（）;

displayCard.setText（"DECKISSHUFFLED!

"）;

}

returntrue;

}

publicvoidshuffle（）{

currentCard=-1;

for（inti=0;i

intj=（int）（Math.random（）*52）;

Cardtemp=deck[i];

deck[i]=deck[j];

deck[j]=temp;

}

dealButton.enable（）;

}

publicCarddealCard（）{

if（++currentCard

returndeck[currentCard];

else{

dealButton.disable（）;

returnnull;

}

}

}

classCard{

privateStringface;

privateStringsuit;

publicCard（Stringf,Strings）{

face=f;

suit=s;

}

publicStringtoString（）{

returnface+"of"+suit;

}

}

两种洗牌—发牌程序收藏

用指针实现，这种比较低效

#include

#include

voidshuffle（int[][13]）;

voiddeal（int[][13],char*[],char*[]）;

intmain（void）

{

char*suit[4]={"hearts","diamonds","clubs","spades"};

char*face[13]={"one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thrteen"};

srand（time（NULL））;

intdeck[4][13]={0};

shuffle（deck）;

deal（deck,face,suit）;

return0;

}

voidshuffle（intdeck[][13]）

{

intcard,row,column;

for（card=1;card<=52;card++）{

row=rand（）%4;

column=rand（）%13;

while（deck[row][column]!

=0）{

row=rand（）%4;

column=rand（）%13;

}

deck[row][column]=card;

}

}

voiddeal（intdeck[][13],char*face[],char*suit[]）

{

intcard,row,column;

for（card=1;card<=52;card++）

for（row=0;row<=3;row++）

for（column=0;column<=12;column++）

if（deck[row][column]==card）

printf（"%sof%s\n",face[column],suit[row]）;

}

第二种是直接用结构体实现，比较高效

#include

#include

structcard{

char*suit;

char*face;

};

typedefstructcardCard;

voidfillDeck（Card*,char*[],char*[]）;

voidshuffle（Card*）;

voiddeal（Card*）;

intmain（void）

{

Cardcard[52];

char*suit[4]={"hearts","diamonds","clubs","spades"};

char*face[13]={"one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thrteen"};

srand（time（NULL））;

fillDeck（card,face,suit）;

shuffle（card）;

deal（card）;

return0;

}

/*

voidshuffle（intdeck[][13]）

{

intcard,row,column;

for（card=1;card<=52;card++）{

row=rand（）%4;

column=rand（）%13;

while（deck[row][column]!

=0）{

row=rand（）%4;

column=rand（）%13;

}

deck[row][column]=card;

}

}

voiddeal（intdeck[][13],char*face[],char*suit[]）

{

intcard,row,column;

for（card=1;card<=52;card++）

for（row=0;row<=3;row++）

for（column=0;column<=12;column++）

if（deck[row][column]==card）

printf（"%sof%s\n",face[column],suit[row]）;

}*/

voidfillDeck（Card*deck,char*face[],char*suit[]）

{

inti;

for（i=0;i<52;i++）{

deck[i].face=face[i%13];

deck[i].suit=suit[i/13];

}

}

voidshuffle（Card*deck）

{

inti,j;

Cardtemp;

for（i=0;i<52;i++）{

j=rand（）%52;

temp=deck[i];

deck[i]=deck[j];

deck[j]=temp;

}

}

voiddeal（Card*deck）

{

inti;

for（i=0;i<52;i++）{

printf（"%sof%s\n",deck[i].face,deck[i].suit）;

}

}

用C++写的扑克牌洗牌、发牌和检测牌质量的程序代码

（2010-12-1223:

00:

09）

转载

标签：

c、扑克牌

it

用C++写的扑克牌洗牌、发牌和检测牌质量的程序代码

编译器我用的是VS2008。

执行结果如图：

源文件：

有三个文件，一个是主函数文件扑克牌游戏.cpp

一个是类函数成员的实现文件dapai.cpp，还有一个是系统生成的stdafx.app。

头文件：

有两个，一个是dapai.h,另一个是系统生成的stdafx.h。

可以实现的简单功能：

可以从一副扑克牌（不带王牌）发出n手牌（n<4）,每手牌发m张牌（n*m<52）。

每次执行都是随机发牌，发的牌没有重复出现，可以检测每一手牌的质量，比如有多少对牌出现、是否有同花出现、是否有连对出现、是否有顺子出现。

我只是凭着我的思路写下的。

里面没有复杂的算法，只是一些简单的语句，也有比较详细的注释。

虽然写得不专业，但是我还会继续努力学习下去的。

。

。

下面是源码：

 

//dapai.h文件

#pragmaonce

classdapai

{

public:

 

 intm;//要发几手牌

 intn;//要发牌的张数

 intcount0;//是否有连续的五张牌出现标记

 intcount2;//成对牌出现的对数

 intcount3;//三张同号牌出现的个数

 intcount4;//四张同号牌一起出现的标记

 intcount222;

 voidxipai（）;//洗牌

 voidfapai（int,int）;//发牌

 inta[4][13];//发牌时统计同号牌出现的次数

 intb[4][4];//发牌时统计每中花色出现的次数

 dapai（void）;

 ~dapai（void）;

private:

 intpuke[4][13];

 constchar*color[4];//花色

 char*face[13];//牌面

};

 

 

//stdafx.h:

标准系统包含文件的包含文件，这个是系统生成的stdafx.h

//或是经常使用但不常更改的

//特定于项目的包含文件

//

#pragmaonce

#defineWIN32_LEAN_AND_MEAN  //从Windows头中排除极少使用的资料

#include

#include

 

//TODO:

在此处引用程序需要的其他头文件

 

 

//扑克牌游戏.cpp:

定义控制台应用程序的入口点。

//主函数文件

#include"stdafx.h"

#include"iostream"

#include"dapai.h"

usingnamespacestd;

voidcompare（int（*p1）[13],int （*p2）[4]）//检测哪手牌比较好

{

 intmax=**p2;

 introw1=0;

 for（inti=0;i<4;i++）

 {

  for（intj=0;j<4;j++）

  {

   if（*（*（p2+i）+j）>max）

   {

    max=*（*（p2+i）+j）;

    row1=i;

   }

  } 

 }

 if（max>=5）

 {

  cout<<"第"<

"<

 }

}

int_tmain（intargc,_TCHAR*argv[]）

{

 dapaiA;

 do

 {

  cout<<"你要发几手牌？

"<

  cin>>A.m;

  cout<<"你要发多少张牌?

"<

  cin>>A.n;

  if（A.m*A.n>52）

  {

   cout<<"输入非法，一副扑克牌只有52张，请重新输入!

\n\n";

  }

  if（A.m>4）

  {

   cout<<"输入非法，只允许发4手牌以内！

"<

  }

 }while（A.m*A.n>52||A.m>4）;

 A.xipai（）;

 A.fapai（A.m,A.n）;

 compare（A.a,A.b）;

}

 

 

//dapai.cpp文件

#include"StdAfx.h"

#include"dapai.h"

#incl

展开阅读全文
相关资源
猜你喜欢
相关搜索

当前位置：首页 > 初中教育 > 语文

copyright@ 2008-2022 冰豆网网站版权所有

经营许可证编号:鄂ICP备2022015515号-1