撲克演算法隨機數

『壹』 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; // 抄襲可恥
}