扑克游戏的洗牌算法及简单测试

最新推荐文章于 2024-04-17 08:14:30 发布
最新推荐文章于 2024-04-17 08:14:30 发布
阅读量135 收藏
点赞数
文章标签： c/c++ python
原文链接：https://my.oschina.net/shusheng/blog/91157
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

我在学习《写给大家看的C语言书》这本书时，对书后面附录的一个扑克游戏程序非常感兴趣。源代码在帖子最后。
PS：这本C语言教学书真的很好呀，非常适合我的水平。

在我弄明白作者的程序后，感觉有点小小的遗憾，就是因为作者的发牌程序，当然不是他的算法问题。我真的一直不知道作者的发牌算法竟然是FisherYates算法，当然我以前也根本就不知道什么是FisherYates算法。作者的发牌原理就是每次从牌堆里面随机抽出一张发出去，每次发牌，每次现抽。当然这个随机并不代表真正意义上的随机。我总觉得这个有点不舒服。因为我们玩扑克的时候，都是先洗好了牌，然后从上到下依次拿牌。我打算改造一下作者的程序。

其实很简单，就是把每次随机抽取出来的牌存到一个数组里面就好，而这就是FisherYates算法。你如果不同意的话，可以分析一下。我贴一下代码： 

void ShuffleArray_Fisher_Yates(char* arr, const int len)
{
    int i = len, j;
    char temp;
    if ( i == 0 ) return;
    while ( --i ) {
        j = rand() % (i+1);
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
PS：这段代码我第一次是在http://coolshell.cn/articles/8593.html看到的，原帖作者的代码中，数组是字符型的，这个不重要。
这段代码的原理，其实就是把随机抽到的牌从后往前排列。

http://coolshell.cn/articles/8593.html帖子作者还贴出了其他几个算法，他说大家常用的洗牌算法如下： 
void ShuffleArray_General(char* arr, int len)
{
    const int suff_time = len;
    for(int idx=0; idx<suff_time; idx++) {
        int i = rand() % len;
        int j = rand() % len;
        char temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
这段代码的原理，就是从牌堆里面，随机抽取两张牌交换位置。

还有两个别的算法，不过我没有看明白到底是怎么一回事，我就不再贴出来了。

既然算法不一样，那么就要考虑到底哪种更好一点，或者说哪个更具有随机性。
如果仅仅是比较一下每张牌出现在每个位置上的概率的话，其实是很好实现的。：：帖子作者的结论就是FisherYates算法明显比General算法好。我自己写了一下代码，测试了一下FisherYates算法，结果确实很理想，统计次数越多，效果越明显。我的代码如下： 
#include <stdio.h>
#include <time.h>
#include <ctype.h>
#include <stdlib.h>

#define CARDSNUM 10                                      /* 牌数 */ 
#define NUMXIPAI 1                                       /* 洗牌次数 */ 
#define TONGJINUM 10000000                               /* 统计次数 */ 
#define CARDS cards                                      /* 扑克数组 */ 
#define TONGJI tongji                                    /* 统计数组 */          
#define CARDS_F  int CARDS[CARDSNUM]                     /* 扑克数组定义及函数参数 */ 
#define TONGJI_F __int64 TONGJI[CARDSNUM][CARDSNUM]      /* 统计数组定义及函数参数 */ 

/* 洗牌函数声明 */ 
void InitCards(CARDS_F);
void ShuffleArray_Fisher_Yates(CARDS_F);
void PrintCards(CARDS_F);
void Puke(CARDS_F); 

/* 统计函数声明 */ 
void InitTongji(TONGJI_F);
void Tongjisum(CARDS_F, TONGJI_F);
void PrintTongji(TONGJI_F);
void Tongji(CARDS_F, TONGJI_F);

main()
{
	time_t t; 
	CARDS_F;
	TONGJI_F;
	
	srand(time(&t));

//	Puke(CARDS);
//	PrintCards(CARDS);
	
	Tongji(CARDS, TONGJI);
	PrintTongji(TONGJI);
	
	return 0;
}

void InitCards(CARDS_F)       /*码牌   扑克数组初始化 */ 
{
	int i;
	for(i = 0; i < CARDSNUM; i++)   
	{
		CARDS[i] = i+1;
	}
}

void ShuffleArray_Fisher_Yates(CARDS_F)    /* Fisher_Yates算法 */ 
{
	int i, j, k;

	for(i = CARDSNUM; i > 0; i--)
	{
		
		j = (rand()%(i)); 
		k = CARDS[i-1];
		CARDS[i-1] = CARDS[j];
		CARDS[j] = k;
	}
}

void PrintCards(CARDS_F)   /* 输出牌 */ 
{
	int j;
	
	printf("\nYour Cards Is: ");
	for(j = 0; j < CARDSNUM; j++)
	{
		if(!(j%10))
		{
			printf("\n");
		}	
		printf("%d  ", CARDS[j]);
	}
}

void Puke(CARDS_F)      /* 洗牌 */ 
{
	int i;
	
	InitCards(CARDS); 
	
	for(i = 1; i <= NUMXIPAI; i++)
	{
		ShuffleArray_Fisher_Yates(CARDS);
	}
	

}

void InitTongji(TONGJI_F)              /* 统计数组初始化 */ 
{
	int j, k;
	
	for(j = 0; j < CARDSNUM; j++)
	{
		for(k = 0; k < CARDSNUM; k++)
		{
			TONGJI[j][k] = 0;
		}
	}
}

void Tongjisum(CARDS_F, TONGJI_F)    /* 统计扑克牌的出现位置 */ 
{
	int j, k;
	
	Puke(CARDS);
	
	for(j = 0; j < CARDSNUM; j++)
	{
		k = CARDS[j];
		TONGJI[j][k-1] += 1;
	}
}

void PrintTongji(TONGJI_F)   /* 输出统计结果 */ 
{
	int i, j;
	
	printf("\nTongji Result Is: \n");
	for(i = 0; i < CARDSNUM; i++)
	{
		for(j = 0; j < CARDSNUM; j++)
		{	
			printf("%d  ", TONGJI[i][j]);
		}
		printf("\n");
	}
}

void Tongji(CARDS_F, TONGJI_F)    /* 扑克牌的概率统计 */ 
{
	__int64 i;
	
	InitTongji(TONGJI);
	
	for(i = 0; i < TONGJINUM; i++)
	{
		Tongjisum(CARDS, TONGJI);
	}
}
需要说明的是，我默认用了10个数字测试，测试次数是1千万次。对于洗牌次数，我最初认为洗牌算法开始的时候是按照顺序洗牌的，那么我们可以把已经洗好的牌在用算法洗一次，效果不应该更好吗。但是从测试结果看来，其实没有多大改变，也就是说没有必要反复洗牌。

《写给大家看的C语言书》的附录扑克游戏二十一点代码我也顺便贴出来。需要说明的是，二十一点的计算规则可能有点不一样，代码里面，如果出现J，Q，K的话，是按照10点计算的。而A则既可以按照1点计算，也可以按照11点计算，这取决于哪种更有利。你有兴许的话，该一下就好了。 
/* filename: 21game.cpp
This program plays a game of Blackjack with you. */

/********************************************************
ANSI C standard header files appear next */
#include <stdio.h>
#include <time.h>
#include <ctype.h>
#include <stdlib.h>

/********************************************************
Defined constants appear next */
#define BELL '\a'
#define DEALER 0
#define PLAYER 1

/* Must keep two sets of totals for dealer and for player.
The first set counts Aces as 1 and the second counts Aces
as 11.Unlike "real world" Blackjeck,this program doesn't
allow some Aces to be 1 while others Aces are 11 in the 
same hand. */
#define ACELOW 0
#define ACEHIGH 1
/* Only one global variable is used in this entire program.
The variable holds 0,which means fales initially. Once the 
user enters his or her name in initCardsScreen(), this variable
is set to 1 (for true), so the name is never asked for again
the rest of the progame. */
int askedForName = 0; /* False initially*/
/*********************************************************
This progame's specific prototypes */
void dispTitle(void);
void initCardsScreen(int cards[52], int playerpoints[2],
int dealerPoints[2], int total[2], int * numCards);
int dealCard(int * numCards, int cards[52]);
void dispCard(int cardDrawn, int points[2]);
void totalIt(int points[2], int total[2], int who);
void dealerGetsCard(int * numCards, int cards[52],
int dealerPoints[2]);
void playerGetsCard(int * numCards, int cards[52], 
int playerPoints[2]);
char getAns(char mesg[]);
void findWinner(int total[2]);

/*********************************************************
C's program execution always begins at main() here */
main()
{
	int numCards; /* Equals 52 at beginning of each game */
	int cards[52], playerPoints[2], dealerPoints[2], total[2];
	char ans; /* For user's Hit/Stand or Yes/No pesponse */
	do 
	{
		initCardsScreen(cards, playerPoints, dealerPoints, total, &numCards);
		
		dealerGetsCard(&numCards, cards, dealerPoints);
		printf("\n");  /*Prints a blank line*/
		playerGetsCard(&numCards, cards, playerPoints);
		playerGetsCard(&numCards, cards, playerPoints);
		do
		{
			ans = getAns("Hit or stand (H/S)?");
			if (ans == 'H')
			{
				playerGetsCard(&numCards, cards, playerPoints);
			}
		} while (ans != 'S');
		totalIt(playerPoints, total, PLAYER);
		/* Player's total */
		do
		{
			dealerGetsCard(&numCards, cards, dealerPoints);
		} while (dealerPoints[ACEHIGH] < 17);
		/* 17: Dealer stops */
		totalIt(dealerPoints, total, DEALER);
		/* Dealer's total */
		findWinner(total);
		ans = getAns("\nPlay again (Y/N)? ");
	} while (ans == 'Y');
	return 0;
}

/***************************************************************
This function initializes the face values of the deck of cards
by putting four sets of 1-13 in the 52-card array .Also clears
the screen and displays a title.  */
void initCardsScreen(int cards[52], int playerPoints[2], 
int dealerPoints[2], int total[2], int * numCards )
{
	int sub , val = 1; /* This function's Work variables */
	char firstName[15]; /* Holds user's first name */
	*numCards = 52; /* Holds running total of number of cards */
	for (sub = 0; sub <= 51; sub++)  /* Counts from 0 to 51 */
	{
		val = (val == 14) ? 1 : val; /* If val is 14,resets to 1 */
		cards[sub] = val;
		val++;
	}
	for(sub = 0; sub <= 1; sub++) /* Counts from 0 to 1 */
	{
		playerPoints[sub] = dealerPoints[sub] = total[sub] = 0;
	}
	dispTitle();
	if (askedForName == 0) /* Name asked for only once */
	{
		printf("\nWhat is your first name? ");
		scanf(" %s", firstName);
		askedForName = 1; /* Don't ask prompt again */
		printf("Ok, %s, get ready for casino action!\n\n",
				firstName);
		getchar(); /* Discards newline. You can safely */
	}				/* ignore comliler warning here. */
	return;
}

/*********************************************************
This function gets a card for the player and updates the 
player's points. */
void playerGetsCard(int *numCards, int cards[52], int playerPoints[2])
{
	int newCard;
	newCard = dealCard(numCards, cards);
	printf("You draw: ");
	dispCard(newCard, playerPoints);
}

/***********************************************************
This function gets a card for the dealer and updates the 
dealer's points. */
void dealerGetsCard(int *numCards, int cards[52], int dealerPoints[2])
{
	int newCard;
	newCard = dealCard(numCards, cards);
	printf("The dealer draws: ");
	dispCard(newCard, dealerPoints);
}

/*****************************************************
This function gets a card from the deck and stores it in 
either the dealer's or the player's hold of cards. */
int dealCard(int * numCards, int cards[52])
{
	int cardDrawn, subDraw;
	time_t t; /* Gets for a random value */
	srand(time(&t)); /* Seeds random-number generator */
	subDraw = (rand()%(*numCards)); /* From 0 to numCards */
	cardDrawn = cards[subDraw];
	cards[subDraw] = cards[*numCards - 1]; /* Puts top card */
	(*numCards)--;                  /* in place of drawn one */
	return cardDrawn;
}

/********************************************************
Displays the last-drawn card and updates points with it. */
void dispCard(int cardDrawn, int points[2])
{
	switch (cardDrawn)
	{
		case(11): printf("%s\n", "Jack");
		          points[ACELOW] += 10;
		          points[ACEHIGH] += 10;
		          break;
  		case(12): printf("%s\n", "Queen");
				  points[ACELOW] += 10;
		          points[ACEHIGH] += 10;
		          break;
		case(13): printf("%s\n", "King");
				  points[ACELOW] += 10;
		          points[ACEHIGH] += 10;
		          break;
		default:  points[ACELOW] += cardDrawn;
				  if (cardDrawn ==1)
				  {
  					  printf("%s\n", "Ace");
  					  points[ACEHIGH] += 11;
  				  }
				  else
				  {
  					  points[ACEHIGH] += cardDrawn;
  					  printf("%d\n", cardDrawn);
  				  }
	}
	return;
}

/**************************************************************
Figurs the total for player or dealer to see who won. This
function takes into account the face that Ace is either 1
or 11. */
void totalIt(int points[2], int total[2], int who)
{
	/* The following routine first looks to see if the total
	points counting Aces as 1 is equal to the total points
	counting Aces as 11. If so, or if the total points
	counting Aces as 11 is more than 21, the program uses
	the total with Aces as 1 only. */
	if ((points[ACELOW] == points[ACEHIGH]) || (points[ACEHIGH] > 21))
	{
		total[who] = points[ACELOW];  /* Keep all Aces as 1 */
	}
	else
	{
		total[who] = points[ACEHIGH];   /* Keeps all Aces as 11 */
	}
	if (who == PLAYER) /* Determines the message printed */
	{
		printf("You have a total of %d\n\n", total[PLAYER]);
	}
	else
	{
		printf("The house stands with a total of %d\n\n", total[DEALER]);
	}
	return;
}

/***********************************************************
Prints the winning player. */
void findWinner(int total[2])
{
	if (total[DEALER] == 21)
	{
		printf("The house wins.\n");
		return;
	}
	if ((total[DEALER] > 21) && (total[PLAYER] > 21))
	{
		printf("%s", "Nobody wins.\n");
		return;
	}
	if ((total[DEALER] >= total[PLAYER]) && (total[DEALER] < 21))
	{
		printf("The house wins.\n");
		return;
	}
	if ((total[PLAYER] > 21) && (total[DEALER] < 21))
	{
		printf("The house wins.\n");
		return;
	}
	printf("%s%c", "You win!", BELL);
	return;
}

/**************************************************************
Gets the user's uppercase, single-character response. */
char getAns(char mesg[])
{
	char ans;
	printf("%s", mesg); /* Prints the prompt message passed */
	ans = getchar();
	getchar();  /* Discards newline. You can safely ignore */
	return toupper(ans);    /* compiler warning here. */
}

/************************************************************
Clears everything off the screen. */
void dispTitle(void)
{
	int i = 0;
	while (i < 25)  	/* Clears screen by printing 25 blank */
	{                   /* lines to "push off" stuff that */
		printf("\n");	/* might be left over on the screen */
		i++;			/* before this program */
	}
	printf("\n\n*Step right up to the Blackjack tables*\n\n");
	return;
}

转载于:https://my.oschina.net/shusheng/blog/91157

weixin_34238633
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
php实现简单洗牌算法
12-18
php  /** * 简单洗牌算法 */ $card_num=54; //牌数 print_r(wash_card($card_num)); function wash_card($card_num) { $cards=$tmp=array(); for($i=0;$i<$card_num;$i++){ $tmp[$i]=$i; } for($i=0;$i<$card...
C#实现洗牌算法
09-03
由于和扑克牌的洗牌过程比较相似所以我也就称为洗牌算法了.很多地方都不自觉的需要这个算法的支持.也可以将这个算法扩展为从N个数中取出M个不重复的数(0<M<=N).今天我们看下如何用C#来实现
如何测试洗牌程序
hualusiyu的专栏
11-20 6431
我希望本文有助于你了解测试软件是一件很重要也是一件不简单的事。 　　我们有一个程序，叫 ShuffleArray ()，是用来洗牌的，我见过N多千变万化的 ShuffleArray ()，但是似乎从来没有要想过怎么去测试之。所以，我在面试中我经常会问如何测试 ShuffleArray ()，没想到这个问题居然难倒了很多有多年编程经验的人。对于这类的问题，其实，测试程序可能比算法更难写，代码更多。
洗牌算法
Ice He's Note
05-04 305
1.抽牌法： 从一个数组中随机抽出一张牌（然后最末位的牌去补这个位），抽出的牌放到新数组中。 2.交换法： 每个位置的牌，随机与另外一个位置的牌交换位置。 3.插牌法： 实现类似于交换法。牌堆里先有1张牌，然后第二张牌可以插两个地方——第一张牌的前或后，第3张牌，有3个地方可插…… #include #include #include #include void
游戏洗牌算法——常用+详解最优Knuth_Durstenfeld算法
YF云飞的博客
08-26 6634
游戏常用算法-洗牌算法
php 扑克牌洗牌算法,随机洗牌算法 | 学步园
weixin_30976201的博客
03-16 286
随机洗牌其实我最初想到的也是那3个方法：1判断生成的随机数有没有重复，2.生成一张布尔表，3.双随机数。下面给出我的算法：#include #include #include using namespace std;void RandCard(vector, int); //函数声明int main(int argc, char *argv[]){vector nRetCard;int nC...
洗牌算法总汇以及测试洗牌算法的正确性
sesiria的博客
02-08 287
转载自：http://www.cnblogs.com/TenosDoIt/p/3384141.html洗牌算法汇总以及测试洗牌程序的正确性洗牌可以抽象为：给定一组排列，输出该排列的一个随机组合，本文代码中均以字符数组代表该排列算法1-算法3 都是在原序列的基础上进行交换，算法空间复杂度为O(1)算法1（错误）：随机交换序列中的两张牌，交换n次（n为序列的长度），代码如下：void Shuffle_...
扑克牌发牌洗牌评判算法
07-04
(1) 能洗牌，发牌； (2) 每次发一手牌（5 张）； (3) 能评价手上的牌好坏； (4) 可以模拟发牌人，程序评估发牌人的牌，根据这手牌的质量， 发牌人可以抓一张、两张、或三张牌，换掉手中不要的牌， 然后程序重新评估...
C语言 | Leetcode C语言题解之第27题移除元素
m0_59237910的博客
04-14 427
C语言 | Leetcode C语言题解之第27题移除元素
lesson01:c++入门
2401_82494141的博客
04-11 946
定义命名空间，需使用namespace关键字，后面更着的是命名空间的名字（自定义的），然后接{}，花括号里写命名空间的成员（如变量，函数，类，甚至可以嵌套命名空间）。现在用命名空间解决一下上面的问题：原理：一个命名空间就定义了一个作用域，叫做命名空间域，命名空间中的内容都局限与命名空间中，与命名空间外的内容互不影响。
第十四届蓝桥杯c++b组
m0_74087709的博客
04-12 695
这里我们删除一个元素时，需要将它左右两边的元素都加上它的值，但是我们无法在优先队列随意修改元素，所以这里有一个技巧，先记录下来下标为x的元素更新后的值，先不急着更新优先队列，类似于线段树的懒标记，等到用到了才更新优先队列，当队头的值是最新的值的时候，那么说明更新过了，那么执行删除操作，否则，需要在优先队列中更新它的值。将字符为c1的位置都存储下来，然后枚举到字符为c2时，二分到最大的满足以c2结尾，c1开头的长度大于等于k的位置，然后该位置以及前面的c1都满足，作为对答案的贡献。
C++三大特性（1）——继承
mastershooter的博客
04-12 798
1.基类的private成员无论以什么方式继承，在派生类中都是不可见的，这里的不可见是指基类的私有成员虽然被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。2.基类的private成员在派生类中是不能被访问的，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就需要定义为protected，由此可以看出，protected限定符是因继承才出现的。
解决Dev-C++编译时不支持C++11特性的办法
Beau_Will的博客
04-11 161
Dev-C++的最新的编译器只能支持到C++14，如果想要使用C++17,C++20,C++2a，必须安装一个新的编译器，然后在Dev-C++中重新选择编译器，再按如下操作（只希望使用C++11或者C++14的也按如下操作）：
算法设计与分析实验报告c++实现(生命游戏、带锁的门、三壶谜题、串匹配问题、交替放置的碟子)
Obliviate的博客
04-11 669
1、 编写一个生命游戏： 规则如下：（或者网上找到更详细的规则） 一个人可以有8个邻居； 一个人若只有一个邻居，在下一代会孤独的死去； 若有2或3个邻居，在下一代依然活着； 若有4个或以上邻居，在下一代会因拥挤而死； 死去的人若有3个邻居，在下一代会复活； 所有的死去或复活都在下一代变化时同时发生。 2、 带锁的门： 在走廊上有n个带锁的门，从1到n依次编号。最初所有的门都是关着的。我们从门前经过n次，每次都从1号门开始。在第i次经过时（i = 1,2，..., n)我们改变i的整数倍号锁的状态；如果门是关
C++ //练习 12.14 编写你自己版本的用shared_ptr管理connection的函数。
最新发布
Made in Code
04-17 175
【代码】C++ //练习 12.14 编写你自己版本的用shared_ptr管理connection的函数。
C++Book对象数组初始化
Ct314的博客
04-11 540
定义含5个Book对象的数组b，定义同时将b[0]~b[3]分别初始化为(1,10),(3,30),(5,50),(8,80)；void set(int _qu) //_qu赋值给qu，price为qu的10倍。//_qu赋值给qu，price为qu的10倍。已声明Book类，要求完成类中函数的定义，并编写main函数完成如下的功能。逆序输出对象数据成员qu * price的值，每个数据后带一个空格。根据输入的数据给b[4]的成员赋值；/* 请在这里填写答案 */
pyqt写个星三角降压启动方式2
weixin_49577420的博客
04-13 542
星三角降压启动用可以用类进行封装，就像博图FB块那样。把逻辑都在类里完成，和外界需要交互的暴露出接口。测试过程中，发现类中直接用定时器QTimer会出现问题。然后就把定时器放到外面了。
C++类和对象（四）——类的实现、const、explicit、static
m0_63596031的博客
04-13 487
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。 也就是说，该操作是对this的改变，因为this是隐式传递的，如果不加const便可直接调用函数，有改变this的风险，属于权限放大，这是不被允许的，加了const后属于权限的平移
以python源码向我详细介绍洗牌算法
07-17
当我们谈论洗牌算法时，通常是指将一副牌或一个列表中的元素随机打乱顺序的算法。下面是一个使用Python实现洗牌算法的示例代码： ```python ...希望这个简单的示例能够帮助你理解洗牌算法的实现方式！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值