js摸牌演算法

『壹』 常見的幾種數組排序演算法JS實現

排序，從小大，0坐標的在下面，即排序後小的在下面，大的在上面。

1，冒泡Bubble：從第0個開始，一直往上，與相鄰的元素比較，如果下面的大，則交換。
Analysis：
Implementation：
void BubbleSort(int *pData, int iNum)

2，插入Insertion：與打撲克牌時整理牌很想像，假定第一張牌是有序的，從第二張牌開始，拿出這張牌來，往下比較，如果有比這張牌大的，則把它撥到上一個位置，直到找到比手上的這張更小的（或到頂了），
則把手上的這張牌插入到這張更小的牌的後面。
Analysis：
Implementation：
void InsertionSort(int *list, int length)
{
int i, j, temp;
for (i = 1; i < length; i++)
{
temp = list[i];
j = i - 1;
while ((j >= 0) && (list[j] > temp))
{
list[j+1] = list[j];
j--;
}
list[j+1] = temp;
}
}

3，選擇Selection：從所有元素中找到最小的放在0號位置，從其它元素（除了0號元素）中再找到最小的，放到1號位置，......。
Analysis：
Implementation：
void SelectionSort(int data[], int count)
{
int i, j, min, temp;
for (i = 0; i < count - 1; i++)
{
/* find the minimum */
min = i;
for (j = i+1; j < count; j++)
{
if (data[j] < data[min])
{
min = j;
}
}
/* swap data[i] and data[min] */
temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}

4，快速Quick：先拿出中間的元素來（值保存到temp里），設置兩個索引（index or pointer），一個從0號位置開始往最大位置尋找比temp大的元素；一個從最大號位置開始往最小位置尋找比temp小的元素，找到了或到頂了，則將兩個索引所指向的元素
互換，如此一直尋找交換下去，直到兩個索引交叉了位置，這個時候，從0號位置到第二個索引的所有元素就都比temp小，從第一個索引到最大位置的所有元素就都比temp大，這樣就把所有元素分為了兩塊，然後採用前面的辦法分別排序這兩個部分。總的來
說，就是隨機找一個元素（通常是中間的元素），然後把小的放在它的左邊，大的放右邊，對左右兩邊的數據繼續採用同樣的辦法。只是為了節省空間，上面採用了左右交換的方法來達到目的。
Analysis：
Implementation：
void QuickSort(int *pData, int left, int right)
{
int i, j;
int middle, iTemp;
i = left;
j = right;

middle = pData[(left + right) / 2]; //求中間值
do
{
while ((pData[i] < middle) && (i < right)) //從左掃描大於中值的數
i++;

while ((pData[j] > middle) && (j > left)) //從右掃描小於中值的數
j--;

if (i <= j) //找到了一對值
{
//交換
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
} while (i <= j); //如果兩邊掃描的下標交錯，就停止（完成一次）

//當左邊部分有值(left<j)，遞歸左半邊
if(left < j)
QuickSort(pData, left, j);

//當右邊部分有值(right>i)，遞歸右半邊
if(right > i)
QuickSort(pData, i, right);
}

5，希爾Shell：是對Insertion Sort的一種改進，在Insertion Sort中，從第2個位置開始取出數據，每次都是與前一個（step/gap==1）進行比較。Shell Sort修改為，在開始時採用較大的步長step，
從第step位置開始取數據，每次都與它的前step個位置上的數據進行比較（如果有8個數據，初始step==4，那麼pos(4)與pos(0)比較，pos(0)與pos(-4)，pos(5)與pos(1)，pos(1)與pos(-3)，
...... pos(7)與pos(3)，pos(3)與pos(-1)），然後逐漸地減小step，直到step==1。step==1時，排序過程與Insertion Sort一樣，但因為有前面的排序，這次排序將減少比較和交換的次數。
Shell Sort的時間復雜度與步長step的選擇有很大的關系。Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相對比較簡單，它適合
於數據量在5000以下並且速度並不是特別重要的場合。它對於數據量較小的數列重復排序是非常好的。
Analysis：
Implementation：
template<typename RandomIter, typename Compare>
void ShellSort(RandomIter begin, RandomIter end, Compare cmp)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
typedef typename std::iterator_traits<RandomIter>::difference_type diff_t;

diff_t size = std::distance(begin, end);
diff_t step = size / 2;
while (step >= 1)
{

for (diff_t i = step; i < size; ++i)
{
value_type key = *(begin+i);
diff_t ins = i; // current position

while (ins >= step && cmp(key, *(begin+ins-step)))
{
*(begin+ins) = *(begin+ins-step);
ins -= step;
}

*(begin+ins) = key;
}

if(step == 2)
step = 1;
else
step = static_cast<diff_t>(step / 2.2);
}
}

template<typename RandomIter>
void ShellSort(RandomIter begin, RandomIter end)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
ShellSort(begin, end, std::less<value_type>());
}

6，歸並Merge：先將所有數據分割成單個的元素，這個時候單個元素都是有序的，然後前後相鄰的兩個兩兩有序地合並，合並後的這兩個數據再與後面的兩個合並後的數據再次合並，充分前面的過程直到所有的數據都合並到一塊。
通常在合並的時候需要分配新的內存。
Analysis：
Implementation：
void Merge(int array[], int low, int mid, int high)
{
int k;
int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;

for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
{
if(array[begin1]<=array[begin2])
{
temp[k] = array[begin1++];
}
else
{
temp[k] = array[begin2++];
}
}
if(begin1 <= end1) //若第一個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));
}
if(begin2 <= end2) //若第二個序列有剩餘，直接拷貝出來粘到合並序列尾
{
memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));
}
memcpy(array+low, temp, (high-low+1)*sizeof(int));//將排序好的序列拷貝回數組中
free(temp);
}

void MergeSort(int array[], unsigned int first, unsigned int last)
{
int mid = 0;
if (first < last)
{
mid = (first+last)/2;
MergeSort(array, first, mid);
MergeSort(array, mid+1,last);
Merge(array,first,mid,last);
}
}

『貳』 蘇州麻將的胡牌演算法

蘇州麻將成牌後，給付多少錢由花的多少來決定，花是累計的；
例如：有人清一色七對，5個花，自摸後，應該算花：
清一色10+七對15+成牌5+花5*2+自摸=120；
如果按5銀子/花算，那麼每人應該給付40*5=200銀子；
如果是誰出沖，則由他一人給付200銀子；
逃跑：玩家逃跑扣基礎分（銀子）*120個花
具體演算法如下：
1、底：5花
2、硬花：指中發白，梅蘭竹菊，春夏秋冬，4百搭，4大白板，每個1花
3、明杠：1花（筒萬條）
4、暗杠：2花（筒萬條4個一樣的在手上選擇的杠）
5、字碰：1花（東南西北碰）
6、暗刻：2花（東南西北3個牌在手上）
7、字明杠：3花（東南西北杠）
8、字暗杠：4花（東南西北在手上選擇杠）
9、小門清：5花（不吃不碰不明杠）
10、大門清：10花（沒有風碰，杠，暗刻，沒有硬花）
11、對對胡：5花（以對子的方式構成胡牌，能碰出杠出胡牌，也能不吃不碰胡出，手上以暗刻方式）
12、混一色：5花（一色牌加字牌胡出）
13、七對子：10花（手上胡出，必須有7個對子）
14、清一色：10花（一色牌）
15、杠開（摸花杠，胡牌叫花開，明暗杠，胡牌叫杠開）：5花（摸花和明暗杠，從杠頭上摸上的牌胡牌）
16、包餃子：一人支付3倍費用（放給玩家杠，此杠牌玩家杠開），算杠開
17、搶杠：一人支付3倍費用（有玩家碰了一對，然後摸牌杠此牌，這時有玩家可以胡這個牌），可以多人搶杠，每家都付3倍費用，小牌遵循3花以上（包括3花，搶杠當自摸），才能搶杠。
18、大吊車：5花（玩家碰杠後，手上只剩1張牌時胡牌）
19、天胡：50花（庄起手14張牌，在沒打任何牌之前胡牌）
20、地胡：50花（閑起手13張牌，摸第一張牌的時候胡牌）
21、海底撈月：5花（玩家摸最後一張牌胡牌）

『叄』 跪求福清麻將全套規則,包括怎麼拿牌,以及所有胡牌的方法演算法.查了好多地方都沒個詳細的規則.

該麻將規則沿用了四川麻將血戰到底的基本打法。在麻將牌中去掉了「中，發，白」的字牌，去掉了「東，南，西，北」的風牌。只剩下筒，條，萬，三色牌一共108張。麻將的打法按照當前流行的十三張打法。

主要優勢：

血流成河的麻將術語：

狗子刨坑，越跑越深：意思就是花豬：也叫三花，打完牌後手上的牌筒條萬三種牌都有，就叫花豬。吃包子：打完牌後沒有下叫的人，要給已經下叫和胡牌的人賠錢，賠數按照所做牌型番數的最大番數對被查叫方進行賠償。杠進杠出：每次杠牌輸贏都加番（現實中也有杠進不杠出的規則，就是贏牌算番，輸不算番）。

『肆』 誰能幫我算一下一副牌摸到三張一樣的概率為多少 順便說一下演算法 謝謝！

正確答案是(3/51)×(2/50)=1/425。一共52張牌，第一張隨便抽，不妨假設抽到5（隨便是幾都行），那還剩51張牌，5還有3張，第二次抽到5的概率為3/51，假設等二次抽中，那還剩50張牌，5有2張，第三次抽中概率為2/50，再和3/50相乘即可。（信我必對，我高中概率班級前三）

『伍』 麻將是怎麼算胡

不同地區的胡牌有稍微不同，但是總體規則如下：

缺門可胡。不能吃牌。杠牌補下一張牌。一家胡了並不結束這局，未胡的玩家繼續打，直到有三家胡牌或摸牌結束時游戲結束。若牌摸完時有兩家或以上未胡牌，此時查叫，無叫的給有叫的賠叫。

1、莊家十四張，先出牌，閑家每人十三張牌。

2、可碰、可杠、不能吃。碰、杠後的牌要亮出牌面（即使是暗杠也要全部亮出牌面）。沒有「門前清」這個概念。

3、放炮的一個人負責，與其他人無關。

4、杠牌後補下一張牌。

5、別人打出牌時若放棄胡牌，在同一圈內不能胡另一人打出的相同的牌直到自己摸牌，但不相同的可以胡。如胡25萬，下家打2萬不胡，對家打2萬也不能胡，但打5萬可以胡。

6、杠上炮時，點炮者將剛杠所得轉移給被點炮者。若杠後點炮超過一響，點炮者要另賠出剛杠所得的點數給被點者。

相關術語

血戰到底：一家胡了並不結束這局，而是未胡的玩家繼續打，直到有三家都胡或者餘下的玩家摸完牌。這樣先胡的不一定獲利最多，點炮的也能翻身，提高了博弈性和趣味性。牌局結束，一並結算。

刮風下雨：杠在結算時算錢。

莊家：第一局隨意，以後每一局由上一局第一個胡牌者當庄，若是一炮雙響或一炮三響，由放炮者當庄。

甩色子：由莊家擲兩枚骰子以確定端牌的起始位置。

跳牌：莊家摸第14張牌時需隔一沓牌摸上面一張，此謂跳牌。

定張：在一局的開始定下不要哪門牌，以後不能改。一般將一張此顏色的牌面朝下擺放，第一輪打出。

缺（天缺）：一局開始摸上牌後就只有兩門牌甚至一門牌，此時報缺。

搭子（坎）：三張數字連續的牌或三張相同的牌稱為一個搭子或一坎牌。

『陸』 推倒胡各種胡怎麼算錢

根據番數的，不同牌型有不同番數演算法，具體如下：

一、屁和（1番）底金×1

二、對對和（2番）底金×2

三、門前清對對和（5番）底金×5

四、明杠（+1番）底金×2

五、暗杠（+1番）底金×2

六、搶杠和（+2番）底金×4

七、杠上花（+2番）底金×4

八、清一色（4番）底金×4

九、清對對胡（8番）底金×8

十、門前清清一色（8番）底金×8

十一、包賠清一色（12番）底金×4×3

十二、包賠對對胡清一色（24番）底金×8×3

十三、七對（4番）底金×4

十四、龍七對（8番）底金×8

十五、雙龍七對（16番）底金×16

十六、三龍七對（64番）底金×64

十七、清七對（32番）底金×32

十八、清龍七對（64番）底金×64

十九、清雙龍七對（128番）底金×128

二十、清三龍七對（256番）底金×256

可把麻將技巧分為上中下三級。

（一）抓進六筒不會換出九筒的譬如有七、八、九筒一順，抓進一張六筒仍打六筒——這類人的麻將技巧僅能管理現成的牌，而換一張打的念頭還不能產生。當然，聽三交而不聽，生熟張不甚明了之類的毛病也包括在內。這是下級。

（二）抓進六筒會打九筒的同前例，能換打九筒，說明已看清九筒是大幺，比較地不易給人家便宜。他已經了解生熟張之別，在全副牌的過程中，可不至於蝕搭。這是中級。

（三）抓進九筒而換打六筒的同前例，能這樣打，說明水準更高了，因為他抓進一張九筒，而知九筒是生張，六筒的危險倒少，已能解除幺、九熟於中心張子的死限制，這顯然是更進一級的技巧了。他不但能看透生張的分別、而且還會因時制宜，隨機應變，已到出神入化的地步了。這是上級。

『柒』 打麻將如何算牌

1，要知彼，先知己。隨時能夠看清自己的手牌，除了起手牌要會快速整理以外，更多的體現在摸牌進張時，能夠快速判斷自己應該打哪一張才有利於進張最寬。這個是經驗來的，打多了很容易就會的。

2，知己後知彼。接著，要學會判斷接下來自己的進張概率有多少 ，是在牌池中，還是在別人手上。例如，自己需要5萬，那我們先判斷剩餘5條的張數，再去分析對手打34萬，或者67萬的情況，以此來判斷是否在對手手上，畢竟這種可以跟鄰牌靠張的還算好判斷一些。

3，計算和牌番型。我們在有多種聽牌選擇時，要學會判斷哪種牌型番值比較高，或者是哪種牌型容易胡的，根據目的不同，從而去決定做牌思路，這個也是需要訓練的，畢竟平時大家娛樂時還是少用到的，鍛煉時間就少了。最後還是跟大家強調，麻將終究是外物，要適當娛樂，拒絕賭博，做個生活健康的人。

打麻將的技巧：

1、一副碰一副一搭

玩牌常常遇到一種情況，副子多一張，可掛搭也可碰，碰了即是碰啥還要啥，如三三四五萬，碰了三萬還要三六萬。要看實際情況而定。一是看搭子夠不夠。你手中之牌搭子不夠，多餘閑張又多是邊沿張和風字，不好掛搭，應該碰；搭子夠，甚至搭子不太好，一般不應該碰。

二是看方位。如果莊家很興，況且已經連庄，碰了可隔空莊家，那就應該碰牌，起到制控莊家的作用。如果是你的下手打牌，可以碰;上手打牌，應該揭牌而不考慮碰。三看是否停口。如果碰了可以停口，就應該碰;如果是上張停口牌，碰了還不停口，那就一般應揭牌不應該碰。

2、點炮有技巧，防大不防小

實戰中，點炮時常發生。點炮的原因有多種，幾局牌打下來，不點炮的可能是零。因此，從心理上，不能把點炮視為大忌或重負。如果背著沉重的包袱打牌，那就像蝸牛爬行，永遠也難走到勝利的前沿。

點炮有個原則，當自己牌力強時，特別是有大牌時，只要不給做大牌家點炮，生張、險張該拼還是要拼的。俗話說：「敢打敢闖，神清氣爽。」「一拼一博，端掉一窩。」實戰中，緊要關頭，往往就是狹路相逢，必死則生。

3、舍牌三招，時刻記牢

舍牌有三個基本功，一是舍牌要隱蔽，舍牌過程中，要隱蔽意圖，不能讓對手窺測到你的做牌方向;二是舍牌會引誘，通過舍牌，製造騙局，勾引對手打出自己需要的牌;三是出牌講究牽制，什麼時候讓吃，什麼時候讓碰，扣住什麼牌，先出什麼牌，後出什麼牌，都要把握分寸。

『捌』 麻將的演算法公式麻將的演算法公式

一分鍾學會麻將的數學公式：nAAA+mABC+DD就贏了，mn可以等於0。

AAA就是三個一樣的牌，ABC就是順子，DD就是對子。mn可以為0，這句話得用高中數學來理解：mm中可以至少有1個為0。

實例分析：

發牌一開始拿到手，莊家14張牌，閑家13張牌。想要胡，就在接下來摸牌、打牌、對吃杠的過程中想辦法使這13張牌符合nAAA+mABC+DD的規律。注意：東南西北中發白這7張牌不能組成ABC的形式，只能組成AAA。

-摸牌、打牌莊家先打一張不摸牌。輪到閑家，先摸一張牌，再打一張。再輪到下一個人。主要是把手上不利於組成公式的牌打掉。

吃、對（碰）、杠：

我有5條和6條。這時，如果我的上家出7條或者4條，那我就可以叫「吃」。通用規律是：

當上家出的牌可以幫我組成順子ABC形式時；

其他人沒有叫「對（碰）、杠、胡」

以上條件同時滿足，就可以叫「吃」。然後把這對順子拿出來，平放在旁邊。

聽牌、胡牌：

經過以上步驟之後，最終會里標准公式差一張牌。這時就叫聽牌。如上圖，我有兩個AAA型，即m=2。它們是：三個東風，三個發財。這兩個放在旁邊的，就是我對來的。最右邊有1個ABC型，它是7條8條9條。其次是一個DD型——兩個八萬。注意，有且只能有一個DD。

還有兩張單牌，3萬和5萬。這時，我只要摸一張4萬，或者我的上家出一張4萬，我就可以胡牌了。最終我胡牌的公式就是2AAA+2ABC+DD。