जादूगर से पूछो #221

मैं ज़्यादा पोकर नहीं खेलता, इसलिए डेविड मैथ्यूज़ से पूछना पड़ा कि "डीलर ऐड-ऑन" क्या होता है। उन्होंने क्या कहा, यहाँ पढ़िए।

डीलर का ऐड-ऑन एक अतिरिक्त और वैकल्पिक शुल्क है जो आपको पंजीकरण के समय दिया जाता है। यह ऐड-ऑन राशि डीलरों को टूर्नामेंट में उनके द्वारा बिताए गए समय के बदले में दी जाती है। आमतौर पर आपको शुरुआती चिप्स की एक अतिरिक्त संख्या मिलती है, उदाहरण के लिए, 2000 के बजाय 2500।

चाहे आप ऐड-ऑन खरीदें या नहीं, टिप देना हमेशा वैकल्पिक होना चाहिए। अगर मैंने ऐड-ऑन खरीदा होता, तो मुझे टिप देने का मन कम होता। वैसे, मैं हमेशा ऐड-ऑन खरीदता हूँ। मुझे यकीन नहीं है कि EV के लिहाज से यह गणितीय रूप से सही है या नहीं, लेकिन अगर मैं टूर्नामेंट में खेलने जा रहा हूँ, तो ऐसा करना ही सही लगता है।

मैं डेव से सहमत हूँ। मैं अपनी बात को आगे बढ़ाते हुए कहना चाहूँगा कि मैं टूर्नामेंट में खिलाड़ियों को री-बाय और वाइल्ड कार्ड परचेज़ जैसी वैकल्पिक फीस देकर परेशान करने का भी विरोध करता हूँ, जब तक कि वे फीस किसी तरह खिलाड़ियों को वापस न कर दी जाएँ, जो आमतौर पर नहीं होता। अगर टूर्नामेंट कैसीनो के लिए किसी भी तरह से लाभदायक नहीं होता, तो कृपया दिखावा छोड़ दें और खिलाड़ियों को प्रवेश के लिए पहले से ज़्यादा भुगतान करने पर मजबूर करें।

अगर डीलर ऐड-ऑन न होता, तो मुझे लगता है कि विजेताओं के लिए डीलरों को टिप देना उचित होता। अगर मुझे मजबूर किया जाए, तो मैं जीत का 1% से 2% देने का सुझाव दूँगा, और जीत जितनी कम होगी, प्रतिशत उतना ही ज़्यादा होगा। इस स्थिति में, मैं कुल डीलर ऐड-ऑन राशि और अपनी जीत और कुल जीत के अनुपात के गुणनफल से टिप कम करूँगा। अगर इससे टिप शून्य या ऋणात्मक हो जाती है, तो आपके सामने दुविधा है। मैं शायद वैसा ही करूँगा जैसा मैं रेस्टोरेंट में अनिवार्य 18%-20% टिप के साथ करता हूँ, बस दिखावे के लिए एक छोटी सी राशि दे दूँगा।

शून्य-हवा में, विमान को प्रत्येक दिशा में 2 घंटे लगेंगे, यानी कुल 4 घंटे। पछुआ हवा के साथ, विमान 600 मील प्रति घंटे की गति से यात्रा करेगा, यानी यात्रा 1000/600 = 1.667 घंटे में पूरी होगी। अग्र-हवा के साथ, विमान 400 मील प्रति घंटे की गति से यात्रा करेगा, यानी यात्रा 1000/400 = 2.5 घंटे में पूरी होगी। इसलिए, हवा के साथ, कुल समय 4.167 घंटे, यानी 10 मिनट अधिक होगा।

इससे बस यही पता चलता है कि औसत निकालना खतरनाक है। आप यह नहीं कह सकते कि किसी यात्रा की औसत गति 500 मील प्रति घंटा है, अगर एक तरफ़ 400 मील प्रति घंटा और दूसरी तरफ़ 600 मील प्रति घंटा है, क्योंकि 400 मील प्रति घंटा वाला चरण लंबे समय तक चलता है।

अगर यह सहज नहीं है, तो 500 मील प्रति घंटे की रफ़्तार वाली हवा पर विचार करें। हवा के साथ तो विमान को सिर्फ़ एक घंटा लगेगा, लेकिन दूसरी तरफ़ से वह अपनी जगह पर स्थिर रहेगा, यानी हमेशा के लिए।

3 से लेकर रॉयल तक के 4 सूट चुनने के लिए विकल्प हैं। 5 रैंक में से 3 चुनने के लिए कॉम्बिन (5,3) = 10 तरीके हैं। बाकी दो कार्ड चुनने के लिए कॉम्बिन (47,2) = 1,081 तरीके हैं। 52 में से 5 कार्ड चुनने के लिए कॉम्बिन (52,5) = 2,598,960 तरीके हैं। इसलिए, रॉयल में 3 कार्ड मिलने की प्रायिकता 4×10×1081/2,598,960 = 1.66% है।

यह log(a ^b )=b×log(a) नियम का एक स्पष्ट विस्तार मात्र है। यह किसी विशेष शब्द के योग्य नहीं है। मुझे लगता है कि यह सूत्र लगातार हार की संभावना से जुड़े कुछ सवालों के जवाब देने में मददगार हो सकता है। उदाहरण के लिए, मान लीजिए कि एक वीडियो पोकर खिलाड़ी जानना चाहता है कि उसे कितने हाथ खेलने होंगे, ताकि रॉयल ड्रॉट की संभावना ठीक 5% हो। इष्टतम रणनीति के साथ, 9/6 जैक या बेटर में प्रति हाथ एक रॉयल ड्रॉट की संभावना 0.00002476 है। कम से कम एक रॉयल ड्रॉट आने की निश्चितता 95% है। इसलिए, 5% रॉयल ड्रॉट में हाथों की संख्या log(1-.95)/log(1-0.00002476) = 120,989 होगी।

हालाँकि, आपको इस समस्या को हल करने के लिए उस सूत्र का उपयोग करने की आवश्यकता नहीं है। इसे इस प्रकार सेट किया जा सकता है:

.05 = (1-0.00002476) ^एन
एन
लॉग(.05) = n × लॉग(1-.00002476)
-1.301 = एन × -0.000010753
एन = 120,989

हाँ। पहले प्रत्येक कार्ड को 0 से 51 तक का मान दें। कार्डों को c1 से c5 तक नाम दें, उन्हें c1 को सबसे छोटा और c5 को सबसे बड़ा क्रम दें। फिर निम्नलिखित फ़ंक्शन को कॉल करें:

int GetIndex(int c1, int c2, int c3, int c4, int c5)
{
रिटर्न कॉम्बिन(सी5,5) + कॉम्बिन(सी4,4)+ कॉम्बिन(सी3,3) + कॉम्बिन(सी2,2) + कॉम्बिन(सी1,1);
}

जहां कॉम्बिन पारंपरिक मान लौटाता है, सिवाय इसके कि यदि पहला मान दूसरे मान से कम है, तो 0 लौटाता है, इस प्रकार:

int संयोजन(int x, int y)
{
यदि (y>x)
0 लौटाएँ;
अन्य
{
int i,n;
एन=1;
(i=x-y+1; i<=x; i++) के लिए
एन*=i;
(i=2; i<=y; i++) के लिए
एन/=i;
वापसी n;
}
}

यदि आप किसी ऐरे तत्व तक पहुंचने के लिए ऐसा कर रहे हैं, तो ऐरे को निम्नानुसार लोड करें।

गिनती=0;
(c5 = 4; c5 < 52; c5++) के लिए
{
(c4 = 3; c4 < c5; c4++) के लिए
{
(c3 = 2; c3 < c4; c3++) के लिए
{
के लिए (c2 = 1; c2 < c3; c2++)
{
(c1 = 0; c1 < c2; c1++) के लिए
{
index_array[गिनती]=जो भी आप चाहते हैं;
गिनती++;
}
}
}
}
}