洗牌编程
1. 编程模拟生成一副扑克牌,发牌给几个玩家的程序，把洗好的一副牌分给几个玩家，依次显示每个玩家的牌。
额，同求
2. c++编程，扑克牌洗牌，将一副扑克牌随机洗好，顺序输出54张扑克牌，求完整代码注：用C++写
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <time.h>
using namespace std;
// 输出辅助
const string strtype[6] = {"方块", "梅花", "红心", "黑桃", "小王", "大王"};
const string strnum[14] = {"", "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
struct Card
{
// type是花色，0~3分别表示不同的花色,4是小王，5是大王
// num是牌上的数字
int type, num;
}dat[54];
int main()
{
// 时间随机函数
srand((unsigned)time(NULL));
int cnt = 0;
for (int i = 0; i < 4; i ++)
for (int j = 1; j <= 13; j ++)
{
dat[cnt].type = i;
dat[cnt ++].num = j;
}
dat[cnt ++].type = 4;
dat[cnt ++].type = 5;
for (int i = 1; i < 54; i ++)
// 交换函数，可以证明这样交换出来的数列是随机的
// 这里就不展开了
swap(dat[i], dat[rand() % i]);
// 输出
for (int i = 0; i < 54; i ++)
{
cout << strtype[dat[i].type];
if (dat[i].type < 4) cout << strnum[dat[i].num];
cout << ' ';
}
cout << endl;
system("pause");
}
我测试过啦，运行的一次结果如下（当然是随机的）：
方块10 黑桃6 梅花9 红心6 方块J 黑桃A 方块4 梅花3 黑桃K 梅花4 方块K 方块5 方块2
黑桃Q 方块A 红心K 梅花K 黑桃10 红心10 红心3 黑桃2 红心2 黑桃8 小王 方块Q 红心J
梅花6 梅花Q 红心9 方块7 梅花7 方块9 梅花J 红心A 红心4 大王 红心Q 红心8 方块6 黑
桃J 方块8 梅花A 方块3 红心7 黑桃7 梅花10 梅花2 黑桃5 红心5 黑桃3 黑桃9 黑桃4 梅
花5 梅花8
请按任意键继续. . .
希望能够帮到你！
3. c语言编程——发牌洗牌模拟，求帮助
实现了2副牌的发牌，和每个人的牌和底牌
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
struct CARD //牌
{
char suit[10]; /*花色*/
char face[10]; /*牌面*/
};
enum { posA, posB, posC, posD};//定义好每个人的位置
struct Postion
{
struct CARD getcard[25];//每人获得的牌
};
struct Postion postion[4];//分配四个位置
struct CARD leftCard[8]; //底牌
struct CARD card[54]; //54张牌
char *suit[]={"Spades","Hearts","Clubs","Diamonds"};
char *face[] = {"A","2","3","4","5","6","7","8","9",
"10","jack","Queen","King"};
/* 函数功能：将52张牌的顺序打乱，
函数参数：结构体数组wCard，表示52张牌
函数返回值：无
*/
void Shuffle(struct CARD *wCard)
{
int i,j;
struct CARD temp;
for (i=0; i<54; i++)
{
j=rand()%54;
temp=wCard[i];
wCard[i]=wCard[j];
wCard[j]=temp;
}
}
/*函数功能：发牌结果
函数参数：结构体数组wCard，表示有54张牌
函数返回值：无
*/
void Deal(struct CARD *wCard)
{
int i,aidx=0,bidx=0,cidx=0,didx=0;
Shuffle(card);//将牌打乱
/*************发第一副牌，只发50张，分别分给A,B,C,D四个位置 4张留底**************/
// 第一次发完50张后，A,B多一张，所以下面第二次让C，D排在前面，两次发完刚好各40张 */
for (i=0; i<50; i++)//发牌数
{
// printf("%10s %5s\n", wCard[i].suit, wCard[i].face);
if(i%4==0)
postion[posA].getcard[aidx++]=wCard[i];
else if(i%4==1)
postion[posB].getcard[bidx++]=wCard[i];
else if(i%4==2)
postion[posC].getcard[cidx++]=wCard[i];
else if(i%4==3)
postion[posD].getcard[didx++]=wCard[i];
}
/**********剩下的四张作为底牌*********/
leftCard[0]=wCard[i++];
leftCard[1]=wCard[i++];
leftCard[2]=wCard[i++];
leftCard[3]=wCard[i++];
Shuffle(card);//再次将牌打乱
/*************发第二副牌，也只发50张，分别分给A,B,C,D四个位置，4张留底，一共8张底**************/
for (i=0; i<50; i++)//发牌数
{
// printf("%10s %5s\n", wCard[i].suit, wCard[i].face);
if(i%4==0)
postion[posC].getcard[cidx++]=wCard[i];
else if(i%4==1)
postion[posD].getcard[didx++]=wCard[i];
else if(i%4==2)
postion[posA].getcard[aidx++]=wCard[i];
else if(i%4==3)
postion[posB].getcard[bidx++]=wCard[i];
}
/**********剩下的四张作为底牌，这样就一共为8张底牌*********/
leftCard[4]=wCard[i++];
leftCard[5]=wCard[i++];
leftCard[6]=wCard[i++];
leftCard[7]=wCard[i++];
}
/* 函数功能：将52张牌按黑桃、红桃、草花、方块花色顺序，面值按A~K顺序排列
函数参数：结构体数组wCard，表示不同花色和面值的52张牌
指针数组wFace，指向面值字符串
指针数组wSuit，指向花色字符串
函数返回值：无
*/
void FillCard(struct CARD wCard[],char *wSuit[], char *wFace[])
{
int i;
for (i=0; i<52; i++)
{
strcpy(wCard[i].suit, wSuit[i/13]);
strcpy(wCard[i].face, wFace[i%13]);
}
// wCard[53].face="Big"; //大小王
strcpy(wCard[52].suit, "Small");
strcpy(wCard[52].face, "ghost");
strcpy(wCard[53].suit, "Big");
strcpy(wCard[53].face, "ghost");
}
void print(char ch)//输出牌
{
int i;
switch(ch)
{
case 'A': for(i=0; i<25; i++)
{
printf("%10s %5s\n", postion[posA].getcard[i].suit, postion[posA].getcard[i].face);
}
break;
case 'B': for(i=0; i<25; i++)
{
printf("%10s %5s\n", postion[posB].getcard[i].suit, postion[posB].getcard[i].face);
}
break;
case 'C': for(i=0; i<25; i++)
{
printf("%10s %5s\n", postion[posC].getcard[i].suit, postion[posC].getcard[i].face);
}
break;
case 'D': for(i=0; i<25; i++)
{
printf("%10s %5s\n", postion[posD].getcard[i].suit, postion[posD].getcard[i].face);
}
break;
}
}
void outputLeftCard()//输出底牌
{
int i;
for(i=0; i<8; i++)
printf("%10s %5s\n", leftCard[i].suit, leftCard[i].face);
}
int main()
{
char pos;
srand(time(NULL));
FillCard(card,suit,face);
//Shuffle(card);
Deal(card);
printf("Please choose your position(A、B、C、D):");
scanf("%c", &pos);
print(pos);//输出你所在位置的牌
/**********下面输出的是，除了你之外其他人的牌**********/
if(pos !='A')
{
printf("A:\n");
print('A');
}
if(pos !='B')
{
printf("B:\n");
print('B');
}
if(pos !='C')
{
printf("C:\n");
print('C');
}
if(pos !='D')
{
printf("D:\n");
print('D');
}
printf("底牌为：\n");
outputLeftCard();//输出底牌
return 0;
}
4. 洗牌问题这样写怎么不对C语言
从进入while循环一开始就不对了，c=1
d=0的时候执行b[c]=b[d]，那么你的编号为2的那张牌就消失了，后面的程序不看
解决办法1
再定义一个数组，两个数组倒着洗牌
解决办法2
定义一个数组，存半副牌
解决办法3
定义一个数，存一张牌，不过剩下的牌需要用
数学方法
推导
补充：如果需要改程序或者写程序，请把原题目发出来
5. c语言编程用扑克牌洗牌和发牌
程序就不写了，写下大致流程
//定义一个数组，或者列表，链表什么的随你
//共52个元素 记作card[52]
//card代表扑克牌的类，有花色（color 枚举，0，1，2，3），点数（枚举 A~K）等属性
card tmp;
for(int i=0;i<52;i++)
{
//计算一个0到52之间的随机数x
tmp=card[i];
card[i]=card[x];
card[x]=tmp;//其实就是交换两张牌
}
//循环下来肯定每张牌都被交换过，有它自己的新位置，也有可能凑巧还在原来的位置
//最后按下标顺序分四堆
6. 谁会c语言编程发牌洗牌程序
这个文件包含了生成牌，发牌，洗牌等操作，不过是java写的，但是程序语言和C还是有很多相通的，你知道了原理自然能自己做
/**
* 文件名：Card.java 2014-1-24 上午8:46:59
* @author Administrator
*/
package cc.icoc.javaxu.card.bean;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**扑克牌卡片类
* 创建时间: 2014-1-24 上午8:46:59
*
* @author 许仕永
* 项目名称: PucCard
* 文件名: Card.java
* 编码: GBK
* @Description：
* @JKD JDK 1.6.0_21
* @version v1.0
* @TODO
*/
public class Card implements Comparable
{
int cardType; //花色
int cardNum; //点数
//存储全部的卡牌
public static List cardsList = new ArrayList();
public Card(int cardNum,int cardType)
{
this.cardNum = cardNum;
this.cardType = cardType;
}
/**初始化卡牌**/
public static void initCards()
{
// String[] types = new String[]{"黑桃","红桃","梅花","方片","小王","大王"};
int[] types = new int[]{4,3,2,1,5,6};
/**
* * 54张，
* 红桃，黑桃，梅花，方块各1--13 13张
* 大小王2张
* 2+13x4=54
*/
for ( int j = 0; j < 4; j++ )
{
for ( int i = 1; i <= 13 ; i++ )
{
cardsList.add(new Card(i, types[j]));
}
}
//大小王的初始化
cardsList.add(new Card(14, types[4]));
cardsList.add(new Card(15, types[5]));
}
/**洗牌 以避免抽牌时抽到的卡牌次序时初始化卡牌的次序**/
public static void cleanCards()
{
Random random = new Random();
//洗牌次数控制在卡牌张数的一半+20以内的随机浮动次数
for ( int i = 0; i < (cardsList.size() / 2 + random.nextInt(20)); i++ )
{
int from = random.nextInt(cardsList.size());
int to = random.nextInt(cardsList.size());
Object temp;
if(to != from)
{
temp = cardsList.get(to);
cardsList.set(to, cardsList.get(from));
cardsList.set(from, temp);
}
}
}
@Override
public String toString()
{
// int[] types = new int[]{4,3,2,1,5,6};
String[] types = new String[]{"♠","♥","♣","♢","大王","小王"};
String typeString = null;
switch (cardType)
{
case 4 :typeString = types[0];break;
case 3 :typeString = types[1];break;
case 2 :typeString = types[2];break;
case 1 :typeString = types[3];break;
case 5 :typeString = types[5];break;
case 6 :typeString = types[4];break;
default :
break;
}
return "Card [" + typeString + " " + cardNum + "]";
}
@Override
public int compareTo(Object o)
{
//黑桃、红桃、梅花、方片、小王、大王 对象 4,3,2,1,5,6
//大小次序 大王、小王、2、A、K、Q、J、10...3。
Card card = (Card)o;
if((card.cardNum == 2) && (this.cardNum != 2))
{
if((this.cardNum < 14))
{
return 1;
}
else if(this.cardNum >= 14)
{
return -1;
}
}
else if((this.cardNum == 2) && (this.cardNum == 2))
{
return card.cardType - this.cardType;
}
if((card.cardNum == 1) && (this.cardNum != 1))
{
if((this.cardNum < 13))
{
return 1;
}
else if(this.cardNum >= 13)
{
return -1;
}
}
else if((this.cardNum == 1) && (this.cardNum == 1))
{
return card.cardType - this.cardType;
}
if((this.cardNum == card.cardNum))
{
return this.cardType - card.cardType;
}
return card.cardNum - this.cardNum;
}
}
7. 编写一个C语言程序，模拟洗牌和发牌的过程
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
structPOKER
{
intnum;//A:1,J:11,Q:12,K:13
intcolor;//黑1,红2,梅3,方4
}s[52];
intmain()
{
inti,num,color;
memset(s,0,sizeof(structPOKER)*52);
srand((unsigned)time(0));
intcount=0;
while(count<52)
{
num=rand()%13+1;
color=rand()%4+1;
intflag_skip=0,flag_end=0;
for(i=0;i<52;i++)
{
if(s[i].num==num&&s[i].color==color)
{
flag_skip=1;
break;
}
}
if(flag_skip==1)
{
continue;
}
while(1)
{
i=rand()%52;
if(s[i].num==0)
{
s[i].num=num;
s[i].color=color;
count++;
break;
}
else
{
continue;
}
}
}
for(i=0;i<52;i++)
{
if(i%13==0)
{
printf(" 玩家%d:",i/13+1);
}
switch(s[i].num)
{
case1:putchar('A');break;
case11:putchar('J');break;
case12:putchar('Q');break;
case13:putchar('K');break;
default:printf("%d",s[i].num);
}
switch(s[i].color)
{
case1: putchar(6);break;
case2:putchar(3);break;
case3:putchar(5);break;
case4:putchar(4);break;
default:printf("");
}
printf("");
}
return0;
}
8. C语言编程题-洗牌
我解决了这个问题,程序如下:
注意:n不能大于500,否则你就得改数组A和B的大小;
#include <stdio.h>
int A[1000],B[500];
void main()
{
int m,n,i;
int flag(int);
void exchange(int);
printf("input n:");
scanf("%d",&n);
for(i=0,m=n*2;i<m;i++) A[i]=i;
i=0;
do {exchange(n); i++;}
while(flag(m));
printf("Times: %d",i);
}
void exchange(int n)
{
int i;
for(i=0;i<n;i++)
B[i]=A[i+n];
for(i=n-1;i>=0;i--)
A[i*2+1]=A[i];
for(i=0;i<n;i++)
A[i*2]=B[i];
}
9. C++编程 洗牌问题
#include<iostream>
#include<stdlib.h>
usingnamespacestd;
#defineN1024
intcmp(char*a,intn)
{
for(inti=0;i<2*n;i++)
{
if(a[i]!=i)return0;
}
return1;
}
voidmain()
{
chartmp1[N],tmp2[N];
intn,count=1;
cin>>n;
//洗第一次
for(inti=0;i<n;i++)
{
tmp1[i*2+1]=i;
tmp1[i*2]=n+i;
}
//后面每洗一次，计数+1,如恢复则中断循环，用两块内存来回捣腾
for(;;)
{
for(inti=0;i<n;i++)
{
tmp2[i*2+1]=tmp1[i];
tmp2[i*2]=tmp1[n+i];
}
count++;
if(cmp(tmp2,n))break;
for(inti=0;i<n;i++)
{
tmp1[i*2+1]=tmp2[i];
tmp1[i*2]=tmp2[n+i];
}
count++;
if(cmp(tmp2,n))break;
}
cout<<count<<endl;
system("pause");
}
10. 题目：编写程序,模拟扑克游戏中的洗牌过程.(只选红桃模拟)。用java怎么弄
洗牌过程？一句话就完成洗牌过程了！！
代码如下：
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CardGame {
public static void main(String[] args) throws IOException {
String[] types={"黑桃","草花","红心","方块"};
String[] value={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
String[] king={"JOKER","joker"};
List<String> cards=new ArrayList<String>();//将一副牌54张放入待洗牌的集合中
for(int i=0;i<types.length;i++){
for(int j=0;j<value.length;j++){
cards.add(types[i]+value[j]);//每个花色的2-A
}
}
cards.add(king[0]);//大鬼
cards.add(king[1]);//小鬼
int m=0;
System.out.println("洗牌之前----------------------------------------------------\n");
for(String str:cards)
{
System.out.print(str+"\t");
m++;
if(m%13==0)
System.out.println();
}
Collections.shuffle(cards);//洗牌动作
m=0;
System.out.println("\n\n洗牌之后-----------------------------------------------------\n");
for(String str:cards)//输出洗牌后的结果
{
System.out.print(str+"\t");
m++;
if(m%13==0)
System.out.println();
}
}
}
我在这里把所有的花色都加入一起洗牌了，楼主可根据需要进行特殊花色的洗牌！！你多执行几次就会发现每次洗牌后的牌的位置都不是一样的！！关键在一个洗牌动作的方法！！