रद्दीकरण सट्टेबाजी प्रणाली विश्लेषक के लिए स्रोत कोड

परिचय

निम्नलिखित प्रोग्राम C++ में लिखा गया है। यह काफी सरल है, C++ का थोड़ा-बहुत अनुभव रखने वाला कोई भी व्यक्ति इसे समझ सकता है कि यह कैसे काम करता है। दस्तावेज़ीकरण की कमी के लिए क्षमा चाहता हूँ, लेकिन तर्क का पालन करके यह समझना मुश्किल नहीं होना चाहिए कि क्या हो रहा है।

//
// रद्दीकरण प्रणाली विश्लेषक
// 10/19/1998
//

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

शून्य टेनबेट();

मुख्य प्रवेश बिंदु()
{
चार च;

करना
{
    टेनबेट();

    cerr << "फिर से खेलें?"
    सिन >> च;
}
जबकि ((ch == 'y') || (ch == 'Y'));

0 लौटाएँ;
}

शून्य टेनबेट()
{
int maxloss, num, bet[1000], lpt, rpt, i, j, curbet, bank, result[2], randwin, g;

लंबी टोटबेट, स्पिन;

cerr << "अधिकतम हानि दर्ज करें "; cin >> maxloss;
cerr << "परीक्षणों की संख्या दर्ज करें "; cin >> num;
cerr << "रूलेट(1) या क्रेप्स(2)?"; सीन >> जी;

परिणाम[0] = 0;
परिणाम[1] = 0;
टोटबेट = 0;
स्पिन = 0;

यदि (g == 1)
{
    रैंडविन = 32767 * 18/38;
}
अन्य
{
    रैंडविन = 32767 * 244 / 495;
}

के लिए (i = 1; i <= num; i++)
{
    बैंक = 0;
    एलपीटी = 1;
    आरपीटी = 10;

    के लिए (j = 1; j <= 10; j++)
    {
        शर्त[j] = 1;
    }

    करना
    {
        यदि (आरपीटी == एलपीटी)
        {
            कर्बेट = शर्त[आरपीटी];
        }
        अन्य
        {
            कर्बेट = बेट[एलपीटी] + बेट[आरपीटी];
        }

        जबकि ((maxloss+bank < curbet)&&(maxloss+bank > 0))
        {
            स्पिन++;

            यदि (अधिकतम हानि + बैंक >= शर्त[एलपीटी])
            {
                टोटबेट += बेट[एलपीटी];

                यदि (रैंड() <= रैंडविन)
                {
                    बैंक += शर्त[एलपीटी];
                    एलपीटी++;
                }
                अन्य
                {
                    बैंक -= शर्त[एलपीटी];
                    शर्त[एलपीटी] *= 2;
                }
            }
            अन्य
            {
                टोटबेट += (मैक्सलॉस + बैंक);

                यदि (रैंड() <= रैंडविन)
                {
                    शर्त[एलपीटी] -= (अधिकतम हानि + बैंक);
                    बैंक += (मैक्सलॉस + बैंक);
                }
                अन्य
                {
                    बैंक -= (मैक्सलॉस + बैंक);
                }
            }

            यदि (आरपीटी == एलपीटी)
            {
                कर्बेट = शर्त[आरपीटी];
            }
            अन्य
            {
                कर्बेट = बेट[एलपीटी] + बेट[आरपीटी];
            }
        }

        यदि (अधिकतम हानि + बैंक > 0)
        {
            टोटबेट+=कर्बेट;
            स्पिन++;

            यदि (रैंड() <= रैंडविन)
            {
                एलपीटी++;
                आरपीटी--;
                बैंक += कर्बट;
            }
            अन्य
            {
                आरपीटी++;
                bet[rpt] = कर्बेट;
                बैंक -= कर्बट;
            }
        }
    }
    जबकि ((lpt <= rpt) && (maxloss + bank > 0));

    यदि (अधिकतम हानि + बैंक == 0)
    {
        परिणाम[1]++;
    }
    अन्य
    {
        परिणाम[0]++;
    }

    यदि (i % 100000 == 0)
    {
        cerr << i << "\n";
    }
}

cerr << "अधिकतम हानि:" << अधिकतम हानि << "\n";
cerr << "नुकसान की संभावना: " << (float)(परिणाम[1])/(float)(संख्या) << "\n";
cerr << "औसत स्पिन: " << (फ्लोट)(स्पिन)/(फ्लोट)(संख्या) << "\n";
cerr << "औसत दांव: " << (फ्लोट)(टोटबेट)/(फ्लोट)(संख्या)<<"\n";
cerr << "जीत: " << परिणाम[0]<<"\nहार: "<< परिणाम[1]<<"\n";
cerr << "कुल दांव:" << totbet<<"\n";
cerr << "कुल जीत/हार: " << (परिणाम[0]*10)-(परिणाम[1]*maxloss) << "\n";
cerr << "कुल स्पिन: " << स्पिन << "\n";
cerr << "शुद्ध हानि: " << (float)((result[0]*10)-(result[1]*maxloss))/(float)totbet << "\n";
}

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