इस पृष्ठ पर
वीडियो पोकर कोड प्रोग्रामिंग -- भाग 2
परिचय
यह वीडियो पोकर प्रोग्रामिंग पर तीन भागों की श्रृंखला का दूसरा भाग है। पहले भाग में, मैंने बेसिक इंजन बनाया था, जिसे चलने में 13.7 घंटे लगे थे। इस वीडियो में, मैंने कुछ शॉर्टकट जोड़े हैं जिससे चलने का समय लगभग 42 मिनट तक कम हो गया है।
वीडियो में विकसित किया गया कोड निम्नलिखित है।
#include <iostream>
#include <time.h>
स्ट्रक्चर कार्ड
{
इंट आर;
इंट एस;
};
शून्य सेटअप(शून्य);
शून्य सौदा(शून्य);
शून्य प्रीड्रॉ (इंट रैंक1, इंट रैंक2, इंट रैंक3, इंट रैंक4, इंट रैंक5, इंट सूट1, इंट सूट2, इंट सूट3, इंट सूट4, इंट सूट5, इंट वजन);
शून्य ड्रा (इंट सी1, इंट सी2, इंट सी3, इंट सी4, इंट सी5, इंट वजन);
int स्कोर(कार्ड डील[]);
int स्कोर_एरे[2598960];
कार्ड डेक[52];
int draw_combinations_array[] = { 1533939, 178365, 178365, 16215, 178365, 16215, 16215, 1081, 178365, 16215, 16215, 1081, 16215, 1081, 1081, 47, 178365, 16215, 16215, 1081, 16215, 1081, 1081, 47, 16215, 1081, 1081, 47, 1081, 47, 47, 1 };
int weighting_array[] = { 5, 43, 43, 473, 43, 473, 473, 7095, 43, 473, 473, 7095, 473, 7095, 7095, 163185, 43, 473, 473, 7095, 473, 7095, 7095, 163185, 473, 7095, 7095, 163185, 7095, 163185, 163185, 7669695 };
__int64 tot_combinations[52];
int tot_weight = 0;
const char* hand_name_array[] = {
"हार", "जैक या बेहतर", "दो जोड़ी", "तीन एक जैसे", "स्ट्रेट", "फ्लश", "फुल हाउस", "चार एक जैसे", "स्ट्रेट फ्लश", "रॉयल फ्लश", "कुल" };
int win_array[] = { 0,1,2,3,4,6,9,25,50,800 };
मुख्य प्रवेश बिंदु()
{
समय_टी आरंभसमय, समाप्तिसमय;
शुरुआत का समय = समय(NULL);
स्थापित करना();
सौदा();
समाप्ति समय = समय(NULL);
printf("कुल सेकंड=\t%i\n", (int)endtime - (int)begtime);
}
शून्य सेटअप(शून्य)
{
int i, c1, c2, c3, c4, c5, count, score_deal_array[52], sc;
कार्ड डील[5];
(i = 0; i <= 51; i++) के लिए
{
डेक[i].r = (इंट)(i / 4);
डेक[i].s = i % 4;
स्कोर_डील_एरे[i] = 0;
कुल संयोजन[i] = 0;
}
गिनती = 0;
(c1 = 0; c1 <= 47; c1++) के लिए
{
सौदा[0] = डेक[c1];
(c2 = c1 + 1; c2 <= 48; c2++) के लिए
{
सौदा[1] = डेक[सी2];
(c3 = c2 + 1; c3 <= 49; c3++) के लिए
{
सौदा[2] = डेक[सी3];
(c4 = c3 + 1; c4 <= 50; c4++) के लिए
{
सौदा[3] = डेक[सी4];
(c5 = c4 + 1; c5 <= 51; c5++) के लिए
{
सौदा[4] = डेक[सी5];
sc = स्कोर(डील);
स्कोर_एरे[गणना] = एससी;
स्कोर_डील_एरे[एससी]++;
गिनती++;
}
}
}
}
}
// std::cerr << "count =\t" << count << "\n";
// for (i = 0; i <= 9; i++)
// std::cerr << hand_name_array[i] << "\t" << score_deal_array[i] << "\n";
}
शून्य सौदा (शून्य)
{
/* int i, c1, c2, c3, c4, c5;
int count = 0;
(c1 = 0; c1 <= 47; c1++) के लिए
{
(c2 = c1 + 1; c2 <= 48; c2++) के लिए
{
(c3 = c2 + 1; c3 <= 49; c3++) के लिए
{
(c4 = c3 + 1; c4 <= 50; c4++) के लिए
{
(c5 = c4 + 1; c5 <= 51; c5++) के लिए
{
ड्रा(सी1, सी2, सी3, सी4, सी5);
गिनती++;
यदि ((गणना % 1000) == 0)
std::cerr << count << "\n";
}
}
}
}
} */
int i,r1, r2,r3,r4,r5;
// चार एक जैसे
(r1 = 0; r1 <= 12; r1++) के लिए
{
(r2 = 0; r2 <= 12; r2++) के लिए
{
यदि (r1 != r2)
{
प्रीड्रा (आर1, आर1, आर1, आर1, आर2, 0, 1, 2, 3, 0, 4);
}
}
}
// पूरा घर
(r1 = 0; r1 <= 12; r1++) के लिए
{
(r2 = 0; r2 <= 12; r2++) के लिए
{
यदि (r1 != r2)
{
प्रीड्रा (आर1, आर1, आर1, आर2, आर2, 0, 1, 2, 0, 1, 12);
प्रीड्रा (आर1, आर1, आर1, आर2, आर2, 0, 1, 2, 0, 3, 12);
}
}
}
// तीन हास्य अभिनेता
for (r1 = 0; r1 <= 12; r1++) // तीन एक समान
{
for (r2 = 0; r2 <= 11; r2++) // पहला सिंगलटन
{
for (r3 = r2 + 1; r3 <= 12; r3++) // दूसरा सिंगलटन
{
यदि ((r1 != r2) && (r1 != r3))
{
प्रीड्रा (आर1, आर1, आर1, आर2, आर3, 0, 1, 2, 0, 0, 12);
प्रीड्रा (आर1, आर1, आर1, आर2, आर3, 0, 1, 2, 3, 3, 4);
प्रीड्रा (आर1, आर1, आर1, आर2, आर3, 0, 1, 2, 0, 1, 24);
प्रीड्रा (आर1, आर1, आर1, आर2, आर3, 0, 1, 2, 0, 3, 12);
प्रीड्रा (आर1, आर1, आर1, आर2, आर3, 0, 1, 2, 3, 0, 12);
}
}
}
}
// दो जोड़ी
for (r1 = 0; r1 <= 12; r1++) // एकल
{
for (r2 = 0; r2 <= 11; r2++) // जोड़ी 1
{
for (r3 = r2 + 1; r3 <= 12; r3++) // जोड़ी 2
{
यदि ((r1 != r2) && (r1 != r3))
{
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 0, 0, 1, 0, 1, 12);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 2, 0, 1, 0, 1, 12);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 0, 0, 1, 2, 3, 12);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 2, 0, 1, 2, 3, 12);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 0, 0, 1, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 1, 0, 1, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 2, 0, 1, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर2, आर3, आर3, 3, 0, 1, 0, 2, 24);
}
}
}
}
// एक जोड़ी
for (r1 = 0; r1 <= 12; r1++) // जोड़ी
{
std::cerr << "एक जोड़ी\t" << r1 << "\n";
for (r2 = 0; r2 <= 10; r2++) // एकल इकाई 1
{
for (r3 = r2 + 1; r3 <= 11; r3++) // सिंगलटन 2
{
(r4 = r3 + 1; r4 <= 12; r4++) // सिंगलटन 3 के लिए
{
यदि ((r1 != r2) && (r1 != r3) && (r1 != r4))
{
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 0, 0, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 2, 2, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 0, 1, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 1, 0, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 1, 0, 0, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 2, 3, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 3, 2, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 3, 2, 2, 12);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 0, 2, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 2, 0, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 0, 0, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 2, 2, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 0, 2, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 2, 0, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 1, 2, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 2, 1, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 0, 1, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 0, 2, 3, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 0, 3, 24);
प्रीड्रा (आर1, आर1, आर2, आर3, आर4, 0, 1, 2, 3, 0, 24);
}
}
}
}
}
// पाँच एकल
(r1 = 0; r1 <= 8; r1++) के लिए
{
std::cerr << "पांच एकल\t" << r1 << "\n";
(r2 = r1+1; r2 <= 9; r2++) के लिए
{
(r3 = r2 + 1; r3 <= 10; r3++) के लिए
{
(r4 = r3 + 1; r4 <= 11; r4++) के लिए
{
(r5 = r4 + 1; r5 <= 12; r5++) के लिए
{
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 0, 0, 0, 4);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 0, 0, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 0, 0, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 1, 0, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 0, 1, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 0, 0, 1, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 0, 1, 1, 12); /> प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 1, 0, 1, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 1, 1, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 0, 0, 1, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 0, 1, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 1, 0, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 0, 0, 1, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 0, 1, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 1, 0, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 1, 0, 0, 0, 12);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 0, 1, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 1, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 1, 2, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 0, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 0, 2, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 2, 0, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 0, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 0, 2, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 2, 0, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 0, 0, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 1, 2, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 2, 1, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 2, 2, 1, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 1, 2, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 2, 1, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 2, 2, 1, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 1, 0, 2, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 0, 1, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 0, 2, 1, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 1, 2, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 1, 0, 2, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 2, 0, 1, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 1, 2, 2, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 1, 2, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 2, 1, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 0, 1, 2, 3, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 0, 2, 3, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 2, 0, 3, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 0, 1, 2, 3, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 0, 2, 3, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 2, 0, 3, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 0, 2, 3, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 0, 0, 3, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 0, 3, 0, 24);
प्रीड्रा (आर1, आर2, आर3, आर4, आर5, 1, 2, 3, 0, 0, 24);
}
}
}
}
}
printf("कुल वजन=\t%i\n", tot_weight);
(i = 9; i >= 0; i--) के लिए
printf("%s\t%i\t%I64i\n", hand_name_array[i], win_array[i], tot_combinations[i]);
}
void predraw(int rank1, int rank2, int rank3, int rank4, int rank5, int suit1, int suit2, int suit3, int suit4, int suit5, int weight)
{
int c1, c2, c3, c4, c5;
c1 = rank1 * 4 + suit1;
c2 = rank2 * 4 + suit2;
सी3 = रैंक3 * 4 + सूट3;
c4 = rank4 * 4 + suit4;
c5 = rank5 * 4 + suit5;
कुल वजन += वजन;
ड्रा(सी1, सी2, सी3, सी4, सी5, वजन);
}
शून्य ड्रा (इंट सी1, इंट सी2, इंट सी3, इंट सी4, इंट सी5, इंट वजन)
{
int i, j, d1, d2, d3, d4, d5, index, sc, draw_score_array[32][10];
int count = 0;
(i = 0; i <= 31; i++) के लिए
{
(j = 0; j <= 9; j++) के लिए
draw_score_array[i][j] = 0;
}
(d1 = 0; d1 <= 47; d1++) के लिए
{
(d2 = d1 + 1; d2 <= 48; d2++) के लिए
{
(d3 = d2 + 1; d3 <= 49; d3++) के लिए
{
(d4 = d3 + 1; d4 <= 50; d4++) के लिए
{
(d5 = d4 + 1; d5 <= 51; d5++) के लिए
{
sc = स्कोर_एरे[गणना];
सूचकांक = 0;
यदि ((d1 == c1) || (d2 == c1) || (d3 == c1) || (d4 == c1) || (d5 == c1))
सूचकांक += 16;
यदि ((d1 == c2) || (d2 == c2) || (d3 == c2) || (d4 == c2) || (d5 == c2))
सूचकांक += 8;
यदि ((d1 == c3) || (d2 == c3) || (d3 == c3) || (d4 == c3) || (d5 == c3))
सूचकांक += 4;
यदि ((d1 == c4) || (d2 == c4) || (d3 == c4) || (d4 == c4) || (d5 == c4))
सूचकांक += 2;
यदि ((d1 == c5) || (d2 == c5) || (d3 == c5) || (d4 == c5) || (d5 == c5))
अनुक्रमणिका += 1;
draw_score_array[index][sc]++;
गिनती++;
}
}
}
}
}
डबल ईवी;
डबल max_ev = 0;
int best_play = 0;
(i = 0; i <= 31; i++) के लिए
{
ईवी = 0.0;
(j = 0; j <= 9; j++) के लिए
ev += draw_score_array[i][j] * win_array[j];
ev /= draw_combinations_array[i];
यदि (ev > max_ev)
{
अधिकतम_ईवी = ईवी;
सर्वश्रेष्ठ_खेल = आई;
}
}
(j = 0; j <= 9; j++) के लिए
{
tot_combinations[j] += weight*draw_score_array[best_play][j] * weighting_array[best_play];
}
}
int स्कोर(कार्ड डील[])
{
इंट स्ट्रेट, फ्लश;
यदि ((deal[0].s == deal[1].s) && (deal[0].s == deal[2].s) && (deal[0].s == deal[3].s) && (deal[0].s == deal[4].s))
फ्लश = 1;
अन्य
फ्लश = 0;
यदि ((deal[0].r != deal[1].r) && (deal[1].r != deal[2].r) && (deal[2].r != deal[3].r) && (deal[3].r != deal[4].r))
{
यदि ((deal[0].r + 4) == deal[4].r)
सीधा = 1;
else if ((deal[4].r == 12) && (deal[3].r == 3)) // व्हील
सीधा = 1;
अन्य
सीधा = 0;
}
अन्य
सीधा = 0;
यदि ((सीधा == 1) && (फ्लश == 1))
{
यदि (deal[0].r == 8)
9 लौटाएँ;
अन्य
8 लौटाएँ;
}
अन्यथा यदि (फ्लश == 1)
5 लौटाएँ;
अन्यथा यदि (सीधा == 1)
4 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[3].r) || (deal[1].r == deal[4].r))
7 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[2].r) && (deal[3].r == deal[4].r))
6 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[1].r) && (deal[2].r == deal[4].r))
6 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[2].r) || (deal[1].r == deal[3].r) || (deal[2].r == deal[4].r))
3 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[1].r) && (deal[2].r == deal[3].r))
2 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[1].r) && (deal[3].r == deal[4].r))
2 लौटाएँ;
अन्यथा यदि ((deal[1].r == deal[2].r) && (deal[3].r == deal[4].r))
2 लौटाएँ;
अन्यथा यदि ((deal[0].r == deal[1].r) && (deal[0].r >= 9))
1 लौटाएँ;
अन्यथा यदि ((deal[1].r == deal[2].r) && (deal[1].r >= 9))
1 लौटाएँ;
अन्यथा यदि ((deal[2].r == deal[3].r) && (deal[2].r >= 9))
1 लौटाएँ;
अन्यथा यदि ((deal[3].r == deal[4].r) && (deal[3].r >= 9))
1 लौटाएँ;
अन्य
0 लौटाएँ;
}