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張。 第三個：復制一下前面的數組，也是對應的就行。