扑克算法随机数

‘壹’ java怎样从54张扑克牌中随机产生五张 不重复的

例如：有数组a = [1,2,3,4,5,6,7,8,9,10]，使用首先产生一个0~10(不包含10)的随机数，用来做数组下标。
Random r = new Random();
int rand = r.nextInt(10);//0~10之间的随机数，但不包含10。
假如rand=3。我们把a[3]放到之前创建好的数组里，你要取5张牌，这个数组就5个长。
然后把a[3]与a[9]的位置交换，交换之后的数组为a=[1,2,3,10,5,6,7,8,9,4]
再次获取随机数，但这里获取的是0~9之间的随机数。
int rand = r.nextInt(9);
rand的值不可能是9，那么下标为9的元素就不可能出现，也就不会重复。
假如这次rand=6，再把a[6]放到之前创建好的数组里。
再把a[6]与a[8]交换，交换之后的数组为a=[1,2,3,10,5,6,9,8,7,4]
再获取随机数时int rand = r.nextInt(8)，那么rand就不可能是8或9。以此类推。
===========
import java.util.Arrays;
import java.util.Random;

public class Test {
public static void main(String[] args) {
int[] puKe = new int[54];
for(int i = 0; i < puKe.length; i++) {
puKe[i] = i + 1;
}
int[] pai = faPai(puKe, 5);
Arrays.sort(pai);
System.out.println(Arrays.toString(pai));
}

public static int[] faPai(int[] puKe, int num) {
int[] pai = new int[num];//用来装载取出的牌，5个长。
int m = 0;//一共取5张，m表示当前取到第几张
int n = puKe.length;//随机数的范围，默认是0~n之间取随机数

Random r = new Random();

for(int i = 0; i < num; i++, n--) {
int rand = r.nextInt(n);//rand为0~n之间的随机数
pai[m++] = puKe[rand];//用随机数做下标，把牌放到pai数组中，然后m++

// rand位置上的牌与n-1位置上的牌交换，因为n再自减，所以n-1也在自减。
int temp = puKe[n - 1];
puKe[n - 1] = puKe[rand];
puKe[rand] = temp;
}
return pai;
}
}
=============
如果你有扑克牌图片，那么就可以把获取到的int[]中的元素做为图片数组的下标了。

‘贰’ 如何产生“随机”，但也“独一无二”的数字

1. 优先：如果数字是保证永不重复，这不是很随机的。 第二：有很多的PRNG算法。 更新： 第三：有一个IETF的RFC的UUID（什么MS调用的GUID），但你应该认识到，（U|G）的UID不加密保护，如果这是你的关注。 更新2： 如果你想喜欢这种在生产代码（不只是为自己的熏陶），请使用预先存在的库。这是代码的那种几乎保证有微妙的bugs，如果你之前（或者即使你有）从来没有做过。 更新3： 下面是文档的.NET的GUID
2. 有很多方法可以生成随机数。这是一个系统/库调用一个伪随机数发生器的seed照你已经描述。 但是 CodeGo.net，也有越来越随机数的其他方式涉及专门的硬件来获得真正的随机数。我知道扑克网站这种硬件的。这是非常有趣的阅读他们是如何做到这一点。
3. 大多数随机数发生器有办法“随机”重新初始化seed值。 （称为随机化）。 如果这是不可能的，你可以将系统时钟初始化seed。
4. 你这个代码示例： 或者，您这本书： 但是，不要自己动手，用现有的库。你不能成为优先人做到这一点。
5. 特别是关于Java的：java.util.Random使用线性同余发生器，这不是很好java.util.UUID#randomUUID()用途java.security.SecureRandom，适用于各种加密安全随机数据生成器的界面-默认是基于SHA-1的，我相信。 的UUID / GUID是不一定随机 人们很容易找到那些比好得多的RNG的java.util.Random如Mersenne扭曲或乘用携带
6. 我知道你正在寻找一种方法来生成随机的C＃。如果是的话，RNGCryptoServiceProvider的是你在找什么。 [编辑] 如果产生一个相当长的RNGCryptoServiceProvider的数目，它很可能是唯一的，但不存在供货保证。从理论上讲，真正的随机数是唯一的。你滚骰子2，你可能会得到两个头的，但他们仍然是随机的。真正的随机！ 我想申请的是unique的支票，你只需要保持滚动生成的数字历史你了。

‘叁’ 一副扑克牌一次编号100到154，使用一次循环进行洗牌，使用随机数random（x）产生0 到x-1之间的数字，

import java.util.Random;
public class Test {
public static void main(String []args){
int []pook=new int[54];
int t=54;
Random rm=new Random();
int k=101;
for(int i=1;i<=54;i++)
{
pook[i-1]=rm.nextInt(t);
System.out.println(k+": "+pook[i-1]);
k++;
}

}
}

‘肆’ 扑克牌算法题

一副牌中有4种花色，同一个花色的牌不可能成对。所以先从四个花色中选出2个，再从A到K的13个数字中选一个成对，第三张牌无关紧要，随意就好，因此概率为： 如有不对，请大家批评指正。

‘伍’ 扑克牌算法概率

随机抽三张，抽到一对或三张同点，答主图视左边公式是对的，右边答案也是对的，但是当中数字的分母线下漏乘一个50，即应该是52*51*50*49。

‘陆’ 用简单c语言，随机输出17张扑克牌，包括花色。大小王也要随机。

1、C语言提供了一些库函数来实现随机数的产生。C语言中有三个通用的随机数发生器，分别为 rand函数， random函数， randomize 函数
但是rand函数产生的并不是真意正义上的随机数，是一个伪随机数，是根据一个数，称之为种子，为基准以某个递推公式推算出来的一系数，当这系列数很大的时候，就符合正态公布，从而相当于产生了随机数，但这不是真正的随机数，当计算机正常开机后，这个种子的值是定了的，除非破坏了系统，为了改变这个种子的值，C提供了srand()函数，它的原形是void srand( int a)。
在调用rand函数产生随机数前，必须先利用srand()设好随机数种子，如果未设随机数种子，rand()在调用时会自动设随机数种子为1。一般用for语句来设置种子的个数。

2、例程：

#include"stdio.h"
#include<stdlib.h>
#include<math.h>
intmain()
{
charstr[13][5]={{"A"},{"2"},{"3"},{"4"},{"5"},{"6"},{"7"},{"8"},{"9"},{"10"},{"J"},{"Q"},{"K"}};
intb[]={1,2,3,4};//1红桃2黑桃3放片4梅花
charstr1[5][10]={{"红桃"},{"黑桃"},{"方块"},{"梅花"},{}};
srand(NULL);
inta,c,i;
intarr[17][2]={0};//记录17个数字a[i][0]表示数字a[i][1]表示颜色一共54张牌，4张A--K1大王1小王1-4=>A5-8=>253=>小王54大王,产生不重复的17个数字
intk=0;
while(k<17)
{
a=rand()%54+1;//a<53时候a=(a-1)/4;//1-4=>05-8==>1
//printf("%3d",a);
if(a<53)
{
a=(a-1)/4;
c=rand()%4;
for(i=0;i<17;i++)
{
if(a==arr[i][0]&&c==arr[i][1])
break;
}
if(i<17)
{
arr[k][0]=a;
arr[k][1]=c;
k++;
}
}
if(a==53||a==54)
{
for(i=0;i<17;i++)
{
if(a==arr[i][0])
break;
}
if(i<17)
{
arr[k][0]=a;
arr[k][1]=4;
k++;
}

}
}
for(i=0;i<17;i++)
{
//printf("%s%s
",str1[arr[i][1]],str[arr[i][0]]);
printf("%d",arr[i][0]);
}
}

‘柒’ 一个随机产生52张扑克牌的程序问题

private Ch10CardLib.Card[] cards;//这里面的cards是数组吗?如果是那Ch10CardLib.Card[] 是什么类型的?不是数组又表示什么呢?
==========是 Card 类型的数组，Ch10CardLib 是自定义的命名空间（见 namespace Ch10CardLib）

cards[suitVal * 13 + rankVal - 1] = new Card((Suit)suitVal, (Rank)rankVal);//"suitVal * 13 + rankVal - 1"这个表达式是什么意思?如果cards[]是数组那么cards[]=new Card( ,)这个呢?
=============是把 52 张牌映射到数组下标，从 Club Ace 开始到 Club King，接着 Diamond Ace 到 Diamond King。。。分别是 0 到 51.

Shuffle() 方法里面是新建一个临时的 Card 数组 newDeck，newDeck[i] 表示排在第 i 歌位置的牌，以及一个布尔类型的数组 assigned ，assigned[i] 表示第 i 个位置是否已有牌。
变量 i 从 0 到 51，不断地产生代表位置的随机数 destCard，直到 assigned[destCard] 未有放置牌，将 card[i] 代表的牌放进 newDeck[destCard] 中。
最后把 newDeck 的牌拷贝到 card 中。

其实这种算法效率比较低，因为牌放多了，再随机寻找一个空位置的可能性就降低了。更好的算法是随机产生数对，作为要交换的两张牌的位置。代码如下：
public void Shuffle()
{
Random sourceGen = new Random();
for (int i = 0; i < 52; ++i)//这个 52 可以设置得更大些
{
int c1 = sourceGen.Next(52);
int c2 = sourceGen.Next(52);
// swap cards[c1] and cards[c2]
Card tmp = cards[c1];
cards[c1] = cards[c2];
cards[c2] = tmp;
}
}

‘捌’ 几种扑克牌洗牌算法

洗牌的

几种话先设定好洗牌方式几种比方对分上下交l以及交织洗牌然扑克牌后用随机数生成函数确定单步洗牌作牌的数量多反复几遍即可。

1. 的一个合理的定义就是算法

2. 一副扑克张牌有种陈列方式。

这样做的好处：

给出的洗牌算算法应该可以等概率地生成这种结果中的一种

‘玖’ 十三张扑克算法

积分规则算法如下：

1、牌面大小顺序：A>K>Q>J>10>9>8>7>6>5>4>3>2。

2、牌型大小顺序：一条龙>同花顺>四条>葫芦>同花>顺子>三条>两对>对子>散牌（乌龙）。

3、赢一墩：同一墩，大于其他某个玩家，自己加1注(头墩加1注，中墩加2注，底墩加3注)。

4、输一墩：同一墩，小于其他某个玩家，自己减1注(头墩减1注，中墩减2注，底墩减3注)。

5、强碰（打和）：同一墩，与其他玩家大小一样，自己加0注。

游戏规则：

四人中一人为庄家，（也可以四人对比，） 庄家把除去大小王的一副牌牌分成四份，每份十三张。开牌前，各闲家向庄家下注。

各人把十三张牌排成三段（道），称头（道）、二道及尾（道）。头有三张，二道及尾各五张。头道必须小于二道，二道必须小于尾道，否则称为“相公”。凡“相公”者全赔。

头段因为只有三张牌，因此不算顺、花。只可能是不成花式（称无头），一对或三条。各人排好牌后，打开牌跟庄家比较大小。头跟头比，二道跟二道比，尾跟尾比。

比较时，先比牌型。牌型相同时，比点数。部分玩法的规则，比点数时由最大点数的牌比起，相同时比第二大的牌，如此类推。倘若完全相同，比最大点数牌的花色。

部分玩法的规则订成对庄家稍为有利：只比点数最大的一只牌。倘若相同，一律由庄家胜。任何一方遇上以下的组合通吃，称为“报到”。

‘拾’ 请教关于扑克的算法

我代码已经写的有些眉目了，随机发牌已经写完，摆放算法在纸上画出来了应该没什么大问题，代码明天写，明天下班继续回来看看，应该能搞定。

到时候思考过程我都会写出来，代码部分会放到我的空间，敬请留意。

回答者：风骚的可乐 - 千总 四级 12-13 01:40
----------------------------

问题描述：

打印3行，每行9张扑克，用户随机记录一张之后输入该扑克所在的行号（1-3）
程序打乱顺序两次，用户再输入所记录的扑克在新的矩阵中的行号，也是两次。
程序给出准确结果。

--------------------------------------------------------------

分析：

假设：54张扑克对应54个整数，随机抽取27个排成矩阵。
假设：第i次打乱之后的矩阵为M(i)，用户第i次输入的行号为L(i)。这里i取1,2或3。

进行第一次打乱，我们将得到用户输入的两个数，L(1)和L(2)。此时，我们需要保证同时在M(1)中第L(1)行，且在M(2)中第L(2)行的元素足够

少，假如这时候满足条件的数组是A(1)，其中含元素N(1)个。
那么我们再进行第2次打乱，用户输入L(3)。那么这时候，我们要保证，同时在M(3)中第L(3)行，且在数组A(1)中的元素，有且仅有1个，也就

是N(2)必须为1。

--------------------------------------------------------------

来看一个例子：

假设有如下的整数矩阵
[1] [2] [3]
[4] [5] [6]
[7] [8] [9]
假定我记录了8，那么L(1)=3，那么程序应该知道，用户记录的数字要么是7，要么8，要么9。这时候需要把这3个数放到不同的3行里，这样下

次用户输入行数就能确定两次的交集了。
看看这种移位：
[1] [5] [9]
[4] [8] [3]
[7] [2] [6]
如果拥护输入L(2)=2，程序将可以直接判定，第一次在{ 7,8,9 }中，且第2次在{ 4,8,3 }中的，必然是8这个数。
同理，我们也可以这样移位：
[1] [8] [6]
[4] [2] [9]
[7] [5] [3]
这样，用户的输入就应该是L(2)=1，判定方式同上类似。
可以得出结论，对于3*3的矩阵，可以通过2次判定得出结果。

下面我们把结论推广到27个数：
假定有如下的9*3矩阵
[T1] [T2] [T3]
[T4] [T5] [T6]
[T7] [T8] [T9]
其中，Ti(i=1~9)分别是3*1的矩阵，我们可以通过L(1)和L(2)确定i，因为Ti只有1行3个数，所以后面可以直接通过以上的“按列移位”方法来

确定具体是哪个数。

--------------------------------------------------------------

下面给出测试代码，其中有部分变量和注释是没有实际意义的，如果你仔细看过，相信很容易将他们挑出来删除掉。

代码说明：
(1) 为了方便，我没有将关键代码写成函数形式，如果写成函数形式的话会比较便于推广到n，而不仅仅局限于27个数。
(2) 为了方便，我没有写整数数组与扑克牌的转换代码，实际上这部分功能可以简单的通过数组对应来实现，请自行完成。
(3) 为了方便，代码中用到很多swap，实际上，应该使用自己编写的交换函数来实现这个功能，为了扩展方便，swap的参数已经被写成有规律

的形式
(4) 调试环境：VC6_SP6+WinXP，转载请注明出处：http://hi..com/crazycola，代码开放，抄袭可耻

#include <time.h>

#include <iostream>
#include <cstdlib>
#include <iomanip>

using namespace std;

void printArr(const int* pArr)
{
for( int i=0; i<3; i++ )
{
for( int j=0; j<9; j++ )
cout << setw(3) << pArr[i*9+j] << " ";
cout << endl; // 抄袭可耻
}
}

void main()
{
int line = 0;

srand( (unsigned)time( NULL ) );
int *iArr = new int[27];

int tag = 0;
for( int i1=0; i1<27; i1++ )
{
char cola_temp1 = 'x'; // when you just this without going through
iArr[i1]=1+rand()%54; // you'll be dammed
if( i1==0 ) continue;
do {
tag = 0;
for( int j=0; j<i1; j++ )
if( iArr[j] == iArr[i1] )
{
iArr[i1]=1+rand()%54;
tag = 1;
}
} while( tag==1 );
// cout << iArr[i1] << endl;
}

printArr(iArr);
char cola_temp2 = 't';
cin >> line; // first

int *iArr2 = new int[9];
for( int i3=0; i3<9; i3++ )
iArr2[i3] = iArr[(line-1)*9+i3]; // aha, it's sunny outside

swap(iArr[ 0*9+ 3],iArr[ 1*9+ 3]); swap(iArr[ 0*9+ 4],iArr[ 1*9+ 4]); swap(iArr[ 0*9+ 5],iArr[ 1*9+ 5]);
swap(iArr[ 0*9+ 3],iArr[ 2*9+ 3]); swap(iArr[ 0*9+ 4],iArr[ 2*9+ 4]); swap(iArr[ 0*9+ 5],iArr[ 2*9+ 5]);

swap(iArr[ 0*9+ 6],iArr[ 2*9+ 6]); swap(iArr[ 0*9+ 7],iArr[ 2*9+ 7]); swap(iArr[ 0*9+ 8],iArr[ 2*9+ 8]);
swap(iArr[ 0*9+ 6],iArr[ 1*9+ 6]); swap(iArr[ 0*9+ 7],iArr[ 1*9+ 7]); swap(iArr[ 0*9+ 8],iArr[ 1*9+ 8]);

printArr(iArr);
cin >> line; //second

int smallMatrixFoot = -1;
int *iArr3 = new int[3];
char cola_temp3 = '5'; // 抄袭可耻
for( int i4=0,k=0; i4<9; i4++ )
for( int j=0; j<9; j++ )
if( iArr2[j]==iArr[(line-1)*9+i4] )
{
if( k==0 ) smallMatrixFoot = (line-1)*9+i4; // save for future use
// smallMatrixFoot % 9 = col_num, and ( smallMatrixFoot - col_num

) / 9 = row_num
iArr3[k++] = iArr2[j];
}
// -- start: for test only
/*for( int dbg01=0; dbg01<3; dbg01++ )
cout << iArr3[dbg01] << " ";
cout<<endl;*/
// --end: for test only

int col_num = smallMatrixFoot % 9;

swap(iArr[ 0*9+col_num+1],iArr[ 1*9+col_num+1]); swap(iArr[ 0*9+col_num+1],iArr[ 2*9+col_num+1]);
swap(iArr[ 0*9+col_num+2],iArr[ 2*9+col_num+2]); swap(iArr[ 0*9+col_num+2],iArr[ 1*9+col_num+2]);

printArr(iArr);
char cola_temp = '0';
cin >> line; //third

int bingo = -1;

for( int i5=0; i5<3; i5++ )
if( iArr3[i5]==iArr[(line-1)*9+col_num+i5] )
bingo = iArr3[i5]; // i'm not so happy
// -- start: for test only
/*else
cout << iArr3[i5] << "!=" << iArr[line*9+col_num+i5] << endl;*/
// --end: for test only

cout << endl << "wow, you've remembered " << bingo << " !" << endl;

delete [] iArr3; iArr3 = NULL;
delete [] iArr2; iArr2 = NULL;
delete [] iArr; iArr = NULL; // 抄袭可耻
}