c语言编程如何洗牌

㈠ c语言 洗牌算法

/*洗牌程序:用任何语言,随机分配52张扑克牌到52个位置上,每个位置只容许放一张牌
用1-13表示红心A--K
14-26表示黑桃A,2,3-,Q,K
27-39表示方块A,2,3-,Q,K
40-52表示黑桃A,2,3-,Q,K
也就是生成1-52不重复的随机数，放到数组中*/

#include<iomanip.h>
#include<stdlib.h>
#include<time.h>

const int N=52;
static int a[N];

int create(int n)
{
return (1+rand()%52);
}

int main()
{
int i,j;
srand(time(0));
for(i=0;i<N;++i)
{
a[i]=create(N);
for(j=0;j<i;++j)
{
if(a[j]==a[i])
{
a[i]=(a[i]+1)%52;
}
}
cout<<setw(5)<<a[i];
}
cout<<endl;
return 0;
}

㈡ 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;//其实就是交换两张牌
}
//循环下来肯定每张牌都被交换过，有它自己的新位置，也有可能凑巧还在原来的位置

//最后按下标顺序分四堆

㈢ c语言 洗牌问题

楼上所言即是。悟出即可感受到世间的真正奥义。

㈣ 谁会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;
}
}

㈤ 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;
}

㈥ 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];
}

㈦ c语言程序设计扑克牌游戏

定义一个结构类型表示一张牌，结构包含3个成员，第一个成员char：取值2，3~K，A表示牌名字，第二个成员int:取值2~14表示牌真实大小。第三个成员:结构链表指针。
写一个初始化函数，定义52大小的结构数组，成员值初值分别和牌对应，遍历数组并将每个元素的链表指针依次指向下一个元素地址。这样得到一个初始链表。（相当于一盒新牌）
所有涉及随机数都用rand函数，洗牌分四份就是循环取随机数m=1~n，n是随循环自减，初值52，直到n变成0。每随一次循环就从初始链表中遍历取出对应第m个节点，并从初始链表中将这个节点断开（既前一个节点指针直接指向后一个节点指针）。每取13张就组成一个新的链表。这样获得4个新链表分别表示4个玩家。
最后出牌就是分别遍历自己的链表，利用循环取牌比较结构数值大小。（取出的牌要从链表断开和上面一样，你把取出节点写成独立函数就能反复使用）。

㈧ C语言 洗牌

下面是正确的代码，没有用链表，通过4个数组来做的，必要的注释我都加了。不理解可以问我。

cout相当于printf，cin相当于scanf。

#include "iostream"

using namespace std;

int main()
{
int num;
cout << "请输入特定数n:";
cin >> num;

int *arry = new int[2*num];
int *temp = new int[2*num];
int *t1 = new int[num];
int *t2 = new int[num];
//初始化数组
for(int j=0;j<2*num;j++)
{
arry[j] = temp[j] = j;
}

//以下是循环部分
bool gogo = true;
int count = 0;

while(gogo)
{
//更新奇、偶数组
for(int i=0; i<2*num; i++)
{
if(i<num)
t1[i] = temp[i];
else
t2[(i-num)] = temp[i];
}

//重组temp数组
for(i=0; i<2*num; i++)
{
if(i%2==0)
temp[i] = t2[i/2] ;
else
temp[i] = t1[(i-1)/2];
}

//判断重组后的数组temp是否和原来的数组一样
for(i=0; i<2*num; i++)
{
if(arry[i] != temp[i])
{
break;
}
}
//如果完全相同，则此时 i==2n;
if(i==2*num)
gogo = false;

count++;
}

cout << count << "次后数组恢复到原来的次序。";

return 0;
}

㈨ C语言 编写洗牌的问题

洗牌就随机排序的问题，所以就需要使用库函数rand()，或者自己编写一个伪随机数来实现。

C++里STL里有一个函数random_shuffle()就能实现这样的功能。

#include<stdlib.h>
#include<time.h>
#include<stdio.h>

//洗牌函数
voidrandom_shuffle(int*array,intlen)
{
	int*p=array,temp,pos;
	for(inti=1;i<len;++i)
	{
		pos=rand()%i;
		temp=*p;
		*p++=array[pos];
		array[pos]=temp;
	}
}

//显示函数
voidprint(int*array)
{
	inti;
	constcharsign1[][4]={"红","黑","方","草"};
	constcharsign2[][4]={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

	for(i=0;i<52;++i)
	{
		printf("%s%2s",sign1[array[i]/13],sign2[array[i]%13]);
		if(i%13==12)printf("
");
	}
	printf("
");
}
		
		
		

intmain()
{
	srand(time(NULL));//初始化随机数
	intcard[52],i;
	for(i=0;i<52;++i)card[i]=i;//初始化牌
	print(card);


	random_shuffle(card,52);//洗牌

	print(card);

	return0;
}

㈩ 关于C语言洗牌程序

这种小case也能上竞赛的门面上？ 这个问题其实很简单的啊，就只要三个函数而已。 一个函数对应一种模式，扑克牌的四种花色可以用四个数组来表示，每个数组13张，再加大小王。（或者更简单的你直接都放在一个数组里。） 第一个函数：随机产生四个随机数然后根据这些数字显示对应的值即可。 第二个：先产生27个随机数输出，然后在输出剩下的27张。 第三个：复制一下前面的数组，也是对应的就行。