斗牛有牛的概率

问题：斗牛有点的概率。还有各点数的概率。

游戏玩法：

1、  斗牛的玩法，52张牌，每人派5张牌。5张牌中，其中3张加起来点数为10的倍数的，为牛，而另外2张加起来，取个位数为点数。J、Q、K都当10点。如 K,3,7,6,8 就是K,3,7为牛，6,8为4点。

2、  把纸牌按点数分为1,2,3,4,5,6,7,8,9,10，10种类型。KQJ10为一种。

3、  胜负方式，有点算点数，点数相同算最大的牌。没点都牌大。10点为牛牛。

分情况计算：

1）  五张都为10的情况：C5/16=0.0016806722689076

2）  四张为10，一张为1~9的情况：C4/16*C1/36=0.0252100840336134

3）  三张为10，二张为1~9的情况：C3/16*C2/36=0.135746606334842

4）  二张为10，三张为1~9的情况：C2/16*C3/36=0.32967032967033

5）  一张为10，四张为1~9的情况：C1/16*C4/36=0.3626373626373626

6）  五张都为1~9的情况：C5/36=0.1450549450549451

 

分析：

其中1），2），3）至少有3张为10，所以肯定有牛。

4）当中的三张和为10,20或者二张和为10

5）当中四张1~9当中3张和为10,20或者2张和为10

6）当中：三张加起来等于10或者20的情况。

和为10的有：118,127,136,145,226,235,334 ,442

和为20的有：992,983,974,965,884,875,776,668

将这16种情况按是否有重号重新分类：

118,226,334,442,992,884,776,668 重号的有8种。每种个有24种  情况1

 

127,136,145,235,983,974,965,875不重号的有8种。没种个有64种情况2

19,28,37,46,55  2个和为10     情况3

4）三张为1~9, 3张中选2张和为10，或者3张和为10,20 

情况1,2的共有（24+64）*8*(16*15/2)=84480种。

2张和为10，并且与2张不同点数的情况： 19,28,37,46  28*16*4*(16*15/2)=215040种

有相同的情况：如119，199 共有6*4*2*4*120=23040种

55的情况: 55* 有6*32*120=23040种

555的情况：有4*120=480种

84480+215040+23040+23040+480=346080

4张1~9牌，不能同时满足情况1和情况2，但存在情况1和情况3，或者情况2和情况3同时成立。

证明：不能同时满足情况1和情况2

5）四张为1~9， 4张中选2张和为10，或者3张和为10,20

情况12与情况3组合

118,19      118,28      226,28      226,46      334,46      442,28      442,46      992,28      992,19      334，37

884,28      884,46      776,37      776,46      668,28      668,46      127,19      127,28      127,37

136,19      136,37      136,46      145,19      145,46      145,55      235,28      235,37      235,55

983,19      983,28      983,37      974,19      974,37      974,46      965,19      965,46      965,55

875,28      875,37      875,55

共有40种重复。(6*4*4*20+4*4*4*4*20)*16=(1920+5120)*16=7040*16=112640

19,28     19,37     19,46     28,37     28,46     37,46

共有 4*4*4*4*6*16=1536*16=24576

55,19    55,28     55,37    55, 46

共有6*16*4*16=6144

全为19,1119,1199 有（4*4+6*6）*4*16=208*16=3328

一个重复：119*，199* 有（6*4+4*6）*（36-4*2）*4*16=5376*16=86016

全部不重复：19** 有 (16*28*27/2)*4*16=24192*16=387072

全为5555,1*16种

为555*  4*32*16=128*16=2048

为55**  6*32*31/2*16=2976*16=47616

 

全为118, 1118,1188 有（4*4+36）*8*16=412*16=6656

118* 有 6*4*28*8*16=5376*16=86016

全为127,1127,1227,1277 有 6*4*4*3*8*16=2304*16=36864

127* 有 4*4*4*24*8*16=12288*16=196608

共有  196608+36864+86016+6656+47616+2048+16+387072+86016+3328-24576-112640-6144=708880

1）    五张为1~9，五张中选3张和为10,20

五张牌都为1~9若选定5张牌并且有牛，则最多有2种组合为10,20。

118,884  11884  118,668 11668  118,127  11278  118,136  11368  118,145  11458 

118,983  11389  118,875  11578  226,442  22446      226,668  22668      226,127  12267          226,677    

226,136  12236      226,235  22356      226,965  22569      334,442  23344      334,884  33488

334,145  13345      334,235  23345      334,389  33489      334,974  33479      442,992  24499

442,884  24488      442,127  12447      442,145  12445      442,974  24479      992,127  12799

992,235  23599      992,983  23899      992,974  24799      992,965  25699      884,668  46688

884,145  14588      884,983  34889      884,974  47889      884,875  45788      776,668  66778

776,136  13677      776,974  46779      776,965  56779      668, 136  13668     668, 965  56689

668, 983  36689     668, 875  56678     127,136  12367      127,145  12457      127,235  12357

127,974  12479      127,875  12578      136,145  13456      136,235  12356      136,983  13689

136,965  13569      145, 235  12345     145,974  14579      145,965  14569      145,875  14578

235, 983  23589     235, 965  23569     235, 875  23578     983,974  34789      983,965  35689

974,965  45679      974,875  45789      965,875  56789

共有64种 36*4*11+4*4*4*4*4*21+6*4*4*4*32=35376

情况1：

全为重复 118,11118,11188,11888 有（4+24+24）*8=416

1张：118* 1118*，1188* 有（16+36）*28*8=11648

0张：118**有 24*28*27/2*8=72576

情况2：

全为：127,11127,12227,12777,11227,11277,12277有（64*3+36*4*3）*8=4992

1张：127*，1127*，1227*，1277* 有96*24*3*8=6912*8=55296

0张：127** 有 64*24*23/2*8=141312

共有141312+55296+4992+72576+11648+416-35376=250864

综合所述：C5/16+ C4/16*C1/36+ C3/16*C2/36+346080+708880+250864

          =4368+65520+352800+1305824

=1728512/2598960=

晚上贴上代码版计算。修正后还是有错误。含代码

int[] BullArr = new int[11];//以次计数牛1至牛10、没有牛，
        int all1=0;
        private void button1_Click(object sender, EventArgs e)
        {
            IsBull();
            double all = 52 * 51 * 50 * 49 * 48 / 120;
            textBox12.Text = Convert.ToString(all);
            textBox11.Text = Convert.ToString(BullArr[0]);
            textBox10.Text = Convert.ToString(BullArr[1]);
            textBox9.Text = Convert.ToString(BullArr[2]);
            textBox8.Text = Convert.ToString(BullArr[3]);
            textBox7.Text = Convert.ToString(BullArr[4]);
            textBox6.Text = Convert.ToString(BullArr[5]);
            textBox5.Text = Convert.ToString(BullArr[6]);
            textBox4.Text = Convert.ToString(BullArr[7]);
            textBox3.Text = Convert.ToString(BullArr[8]);
            textBox2.Text = Convert.ToString(BullArr[9]);
            int niu = 0;
            for (int i = 0; i < 10; i++)
                niu += BullArr[i];
            textBox1.Text = Convert.ToString(niu);
            button1.Text = Convert.ToString( all1);
        }
        void IsBull()
        {
            bool[] cardArr = new bool[52];
            int[] posArr = new int[5];
            for (int i = 0; i < 52; i++)//初始化数组
            {
                if (i < 5)
                {
                    cardArr[i] = true;
                }
                else
                    cardArr[i] = false;
            }
            BullArr[10]++;//12345，最小的五张牌肯定无牛
            all1++;
            while (!(cardArr[51] && cardArr[50] && cardArr[49] && cardArr[48] && cardArr[47]))//当然最大的五张牌时退出循环
            {
                all1++;
                int j = 0;
                int i = 0;
                int count1 = 0;
                for (j = 0; j < 51; j++)
                {
                    if (cardArr[j] && cardArr[j + 1])//检查第一个相邻为真和假的J左边的真的个数
                    {
                        count1++;
                        cardArr[j] = false;
                    }
                    if (cardArr[j] && !cardArr[j + 1])//相邻为真和假的时候，互换
                    {
                        cardArr[j] = false;
                        cardArr[j + 1] = true;
                        break;//跳出for，后面的不需检索
                    }
                }
                for (int m = 0; m < count1; m++)//将第一个真和假的前面将所有真都移动到最左边
                {
                    cardArr[m] = true;
                }
                for (j = 0; j < 52; j++)
                {
                    if (cardArr[j])
                    {
                        if (j < 36)
                        {
                            posArr[i] = Convert.ToInt16(j / 4 + 1);//将5张牌对应的下标转换为点数，0~35 为1~9点
                            i++;
                        }
                        else
                        {
                            posArr[i] = 10;///将5张牌对应的下标转换为点数，36~51 为10点
                            i++;
                        }
                    }
                    if (i == 5)
                        break;//不需要检索全部位置，只需检索到5个真即可
                }
                bool[] p = new bool[5];
                p[0] = true;
                p[1] = true;
                p[2] = true;
                p[3] = false;
                p[4] = false;//初始化5张牌选前面3张。
                if ((posArr[0] + posArr[1] + posArr[2]) % 10 == 0)//选前3张牌的情况。有牛则跳出while
                {
 switch ((posArr[3] + posArr[4]) % 10)//个点数牛的累计器++
                    {
                        case 0:
                            BullArr[0]++;
                            break;
                        case 1:
                            BullArr[1]++;
                            break;
                        case 2:
                            BullArr[2]++;
                            break;
                        case 3:
                            BullArr[3]++;
                            break;
                        case 4:
                            BullArr[4]++;
                            break;
                        case 5:
                            BullArr[5]++;
                            break;
                        case 6:
                            BullArr[6]++;
                            break;
                        case 7:
                            BullArr[7]++;
                            break;
                        case 8:
                            BullArr[8]++;
                            break;
                        case 9:
                            BullArr[9]++;
                            break;
                    }
                    continue;
                }
                while (!(p[2] && p[3] && p[4]))//开始转换组合
                {
                    int x;
                    int count = 0;
                    for (x = 0; x < 4; x++)//检索相邻为真和假的J
                    {
                        if (p[x] && p[x + 1])//J左边的真的个数
                        {
                            count++;
                            p[x] = false;
                        }
                        if (p[x] && !p[x + 1])//互换J和J+1的值
                        {
                            p[x] = false;
                            p[x + 1] = true;
                            break;
                        }
                    }
                    for (int s = 0; s < count; s++)//让J左边所有真移到最左边
                    {
                        p[s] = true;
                    }
                    int piont = 0;
                    int piont1 = 0;
                    for (x = 0; x < 5; x++)
                    {
                        if (p[x])
                        {
                            piont += posArr[x];
                        }
                        else
                        {
                            piont1 += posArr[x];
                        }
                    }
                    if (piont % 10 == 0)
                    {
                        switch (piont1 % 10)
                        {
                            case 0:
                                BullArr[0]++;
                                break;
                            case 1:
                                BullArr[1]++;
                                break;
                            case 2:
                                BullArr[2]++;
                                break;
                            case 3:
                                BullArr[3]++;
                                break;
                            case 4:
                                BullArr[4]++;
                                break;
                            case 5:
                                BullArr[5]++;
                                break;
                            case 6:
                                BullArr[6]++;
                                break;
                            case 7:
                                BullArr[7]++;
                                break;
                            case 8:
                                BullArr[8]++;
                                break;
                            case 9:
                                BullArr[9]++;
                                break;
                        }
                        break;
                    }
                    BullArr[10]++;
                }
            }
        }