वीडियो पोकर कोड प्रोग्रामिंग -- भाग 2

परिचय

यह वीडियो वीडियो पोकर प्रोग्रामिंग पर तीन-भागों वाली श्रृंखला का दूसरा भाग है। पहले भाग में, मैंने मूल इंजन बनाया है, जिसे चलाने में 13.7 घंटे लगते हैं। इस वीडियो में, मैं इसे चलाने का समय लगभग 42 मिनट तक कम करने के लिए शॉर्टकट जोड़ता हूँ।

वीडियो में विकसित कोड निम्नलिखित है।

#शामिल करें <iostream>
#शामिल करें <time.h>

स्ट्रक्चर कार्ड
{
int आर;
int एस;
};

शून्य सेटअप(शून्य);
शून्य सौदा(शून्य);
void predraw(int रैंक1, int रैंक2, int रैंक3, int रैंक4, int रैंक5, int सूट1, int सूट2, int सूट3, int सूट4, int सूट5, int वजन);
शून्य ड्रा (int c1, int c2, int c3, int c4, int c5, int वजन);
int स्कोर(कार्ड डील[]);

int स्कोर_सरणी[2598960];
कार्ड डेक[52];
int draw_combinations_array[] = { 1533939, 178365, 178365, 16215, 178365, 16215, 16215, 1081, 178365, 16215, 16215, 1081, 16215, 1081, 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, 7669695 };
__int64 tot_combinations[52];
int कुल भार = 0;

const char* hand_name_array[] = {
"हार","जैक या बेहतर","दो जोड़ी","एक तरह के तीन","सीधे","फ्लश","फुल हाउस","एक तरह के चार","सीधे फ्लश","रॉयल फ्लश","कुल" };
int win_array[] = { 0,1,2,3,4,6,9,25,50,800 };

मुख्य प्रवेश बिंदु()
{
time_t आरंभ समय, अंत समय;
begtime = समय(NULL);
स्थापित करना();
सौदा();
अंत समय = समय(शून्य);
प्रिंटफ("कुल सेकंड=\t%i\n", (int)अंत समय - (int)प्रारंभ समय);
}

शून्य सेटअप(शून्य)
{
int i, c1, c2, c3, c4, c5, गिनती, स्कोर_डील_एरे[52], sc;
कार्ड डील[5];
के लिए (i = 0; i <= 51; i++)
{
डेक[i].r = (int)(i / 4);
डेक[i].एस = आई % 4;
स्कोर_डील_एरे[i] = 0;
tot_combinations[i] = 0;
}
गिनती = 0;
के लिए (c1 = 0; c1 <= 47;c1++)
{
डील[0] = डेक[c1];
(c2 = c1 + 1; c2 <= 48; c2++) के लिए
{
डील[1] = डेक[c2];
(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 << "गिनती =\t" << गिनती << "\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 गिनती = 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 << गिनती << "\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 != आर2)
{
प्रीड्रा (आर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 != आर4))
{
प्रीड्रा (आर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);
प्रीड्रॉ(r1, r2, r3, r4, r5, 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);
}
}
}
}
}
प्रिंटफ("कुल वजन=\t%i\n", कुल वजन);
(i = 9; i >= 0; i--) के लिए
प्रिंटफ("%s\t%i\t%I64i\n", hand_name_array[i], win_array[i], tot_combinations[i]);
}

शून्य प्रीड्रॉ (इंट रैंक1, इंट रैंक2, इंट रैंक3, इंट रैंक4, इंट रैंक5, इंट सूट1, इंट सूट2, इंट सूट3, इंट सूट4, इंट सूट5, इंट वजन)
{
int सी1, सी2, सी3, सी4, सी5;
c1 = रैंक1 * 4 + सूट1;
c2 = रैंक2 * 4 + सूट2;
सी3 = रैंक3 * 4 + सूट3;
c4 = रैंक4 * 4 + सूट4;
c5 = रैंक5 * 4 + सूट5;
tot_weight += वजन;
ड्रा(सी1, सी2, सी3, सी4, सी5, वजन);
}

शून्य ड्रा (int c1, int c2, int c3, int c4, int c5, int वजन)
{
int i, j, d1, d2, d3, d4, d5, इंडेक्स, sc, draw_score_array[32][10];
int गिनती = 0;
के लिए (i = 0; i <= 31; i++)
{
के लिए (j = 0; j <= 9; j++)
ड्रा_स्कोर_एरे[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) || (डी4 == सी5) || (डी5 == सी5))
सूचकांक += 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)
{
अधिकतम_ev = ev;
सर्वश्रेष्ठ_प्ले = i;
}
}
के लिए (j = 0; j <= 9; j++)
{
tot_combinations[j] += वजन*draw_score_array[best_play][j] * weighting_array[best_play];
}
}

int स्कोर(कार्ड डील[])
{
int सीधा, फ्लश;
यदि ((डील[0].s == डील[1].s) && (डील[0].s == डील[2].s) && (डील[0].s == डील[3].s) && (डील[0].s == डील[4].s))
फ्लश = 1;
अन्य
फ्लश = 0;
यदि ((डील[0].r != डील[1].r) && (डील[1].r != डील[2].r) && (डील[2].r != डील[3].r) && (डील[3].r != डील[4].r))
{
यदि ((डील[0].r + 4) == डील[4].r)
सीधा = 1;
अन्यथा यदि ((डील[4].r == 12) और (डील[3].r == 3)) // पहिया
सीधा = 1;
अन्य
सीधा = 0;
}
अन्य
सीधा = 0;
यदि ((सीधा == 1) और (फ्लश == 1))
{
यदि (डील[0].r == 8)
वापसी 9;
अन्य
वापसी 8;
}
अन्यथा यदि (फ्लश == 1)
5 लौटाएं;
अन्यथा यदि (सीधा == 1)
वापसी 4;
अन्यथा यदि ((डील[0].r == डील[3].r) || (डील[1].r == डील[4].r))
वापसी 7;
अन्यथा यदि ((डील[0].r == डील[2].r) और (डील[3].r == डील[4].r))
वापसी 6;
अन्यथा यदि ((डील[0].r == डील[1].r) और (डील[2].r == डील[4].r))
वापसी 6;
अन्यथा यदि ((डील[0].r == डील[2].r) || (डील[1].r == डील[3].r) || (डील[2].r == डील[4].r))
वापसी 3;
अन्यथा यदि ((डील[0].r == डील[1].r) और (डील[2].r == डील[3].r))
वापसी 2;
अन्यथा यदि ((डील[0].r == डील[1].r) और (डील[3].r == डील[4].r))
वापसी 2;
अन्यथा यदि ((डील[1].r == डील[2].r) और (डील[3].r == डील[4].r))
वापसी 2;
अन्यथा यदि ((डील[0].r == डील[1].r) और (डील[0].r >= 9))
वापसी 1;
अन्यथा यदि ((डील[1].r == डील[2].r) और (डील[1].r >= 9))
वापसी 1;
अन्यथा यदि ((डील[2].r == डील[3].r) और (डील[2].r >= 9))
वापसी 1;
अन्यथा यदि ((डील[3].r == डील[4].r) और (डील[3].r >= 9))
वापसी 1;
अन्य
0 लौटाएँ;
}

द्वारा लिखित: Michael Shackleford