关于扔硬币的概率问题

有趣的话题

如果连续扔了10次硬币，8次向上，2次向下，下一次硬币向下的概率是多少？在我们的认知里，这就是一个独立概率的问题，也就是概率永远是一半，不管前面扔了多少次向上，下一次向下的概率是不会变的，这是一个数学界都公认的原理，但是我偏偏不信科学，我就是觉得应该是向下的概率大，因此我想验证一下。

我是不会真的去扔硬币的，我没那么傻，作为程序员，我当然要用程序去实现，我假设是在投筛子，筛子只有0和1。

有两种情况：

• 第一种是我上面说的那种，假如扔了8次硬币，6次向上，1次向下
  ，向上比向下多那么多次，那么我猜测下一次向下的概率会大一些。
• 第二种情况是我连续扔了5次向上，那么我猜测下一次也应该是向下。

我会计算两种情况下猜测成功和失败的次数。
第一种情况的具体实现是我会投掷10次硬币，如果前7次（threshold ）出现了6次向上和1次向下，那么下一次我猜是向下，如果猜成功了，那么guessSuccess+1，否则guessFail+1，由于出现6次向上和1次向下的概率并不大，我会尝试猜测10000次，看有多少次成功和失败的。
第二种情况的实现和第一种差不多，区别就是前5次全是要向上的，我猜的是第6次

一、第一种情况

public static void main(String[] args) {
        SecureRandomrandom = new SecureRandom();
        // 猜测成功的次数
        int guessSuccess = 0;
        // 猜测失败的次数
        int guessFail = 0;
        // 总共猜测的次数
        int guessTimes=10000;
        // 阈值，也就是我的猜测点，第一种情况，用来控制正面大于反面，或者反面大于正面的数量,第二种情况，用来控制连续投掷正面或反面的次数
        int threshold = 7;
        for (int j = 0; j < guessTimes; j++) {
            // 记录投掷0的数量
            int count0 = 0;
            // 记录投掷1的数量
            int count1 = 0;
            // 我猜测的值
            int guess = -1;
            // 总共投掷的次数
            int rollTimes = 10;
            for (int i = 0; i < rollTimes; i++) {
                // 投掷次数至少要大于等于阈值，才会进入猜测
                if (i >= threshold-1) {
                    if (count0 >= count1 + threshold) {
                        System.out.print("我猜为1" + " ");
                        guess = 1;
                    } else if (count1 >= count0 + threshold) {
                        System.out.print("我猜为0" + " ");
                        guess = 0;
                    } else {
                        System.out.print("没有超过阈值，不管-----" + " ");
                        guess = -1;
                    }
                }
                // 只随机0和1
                int ran = random.nextInt(2);
                System.out.print("随机值为:"+ran + " ");
                if (ran == 1) {
                    if (guess == 1) {
                        guessSuccess++;
                        // 预测成功则停止
                        System.out.println(String.format("此时0有%s个，1有%s个",count0,count1));
                        break;
                    } else if (guess == 0) {
                        guessFail++;
                        System.out.println(String.format("此时0有%s个，1有%s个",count0,count1));
                        break;
                    }
                    count1++;
                } else {
                    if (guess == 0) {
                        guessSuccess++;
                        System.out.println(String.format("此时0有%s个，1有%s个",count0,count1));
                        break;
                    } else if (guess == 1) {
                        guessFail++;
                        System.out.println(String.format("此时0有%s个，1有%s个",count0,count1));
                        break;
                    }
                    count0++;
                }

            }
            System.out.println();
        }
        System.out.println("guessSuccess:" + guessSuccess);
        System.out.println("guessFail:" + guessFail);
    }

用threshold=7运行了5次，结果如下:

1.
guessSuccess:206
guessFail:207
2.
guessSuccess:232
guessFail:204
3.
guessSuccess:215
guessFail:226
4.
guessSuccess:217
guessFail:198
5.
guessSuccess:203
guessFail:204

二、第二种情况

public static void main(String[] args) {
        SecureRandom random = new SecureRandom();
        // 猜测成功的次数
        int guessSuccess = 0;
        // 猜测失败的次数
        int guessFail = 0;
        // 总共猜测的次数
        int guessTimes = 10000;
        // 阈值，也就是我的猜测点，第一种情况，用来控制正面大于反面，或者反面大于正面的数量,第二种情况，用来控制连续投掷正面或反面的次数
        int threshold = 5;
        for (int j = 0; j < guessTimes; j++) {
            // 记录投掷0的数量
            int count0 = 0;
            // 记录投掷1的数量
            int count1 = 0;
            // 我猜测的值
            int guess = -1;
            // 总共投掷的次数
            int rollTimes = 10;
            // 记录上次投掷的点数
            int pre = -1;
            // 记录连续投掷相同点数的次数
            int sameCount = 1;
            for (int i = 0; i < rollTimes; i++) {
                // 连续相同点数
                if (sameCount >= threshold) {
                    if (pre == 0) {
                        System.out.print("我猜为1" + " ");
                        guess = 1;
                    } else {
                        System.out.print("我猜为0" + " ");
                        guess = 0;
                    }
                }
                // 只随机0和1
                int ran = random.nextInt(2);
                System.out.print("随机值为:" + ran + " ");
                // 如果和上次点数相同，sameCount+1，不然恢复初始值
                if (pre == ran) {
                    sameCount++;
                } else {
                    sameCount = 1;
                }
                pre = ran;

                if (ran == 1) {
                    if (guess == 1) {
                        guessSuccess++;
                        // 预测成功则停止
                        System.out.println(String.format("此时0有%s个，1有%s个", count0, count1));
                        break;
                    } else if (guess == 0) {
                        guessFail++;
                        System.out.println(String.format("此时0有%s个，1有%s个", count0, count1));
                        break;
                    }
                    count1++;
                } else {
                    if (guess == 0) {
                        guessSuccess++;
                        System.out.println(String.format("此时0有%s个，1有%s个", count0, count1));
                        break;
                    } else if (guess == 1) {
                        guessFail++;
                        System.out.println(String.format("此时0有%s个，1有%s个", count0, count1));
                        break;
                    }
                    count0++;
                }

            }
            System.out.println();
        }
        System.out.println("guessSuccess:" + guessSuccess);
        System.out.println("guessFail:" + guessFail);

    }

用threshold=5（也就是连续掷出了5次相同的筛子的情况）运行了5次，结果如下:

1.
guessSuccess:960
guessFail:947
2.
guessSuccess:923
guessFail:945
3.
guessSuccess:946
guessFail:980
4.
guessSuccess:901
guessFail:944
5.
guessSuccess:904
guessFail:892

结论

从上面结果看，可以得出这个的确是一个完全随机的独立概率，只能有一半猜成功的。唉，本来还以为可以搞出个数学上的新问题，但是发现还是跟书上学到的结果是一样的，失望。不过这是用程序模拟的，代码本来就是伪随机，可靠性不强。而且以我个人经验，如果现实中真的发生了投掷10次硬币，8次向上，2次向下，那么下一次向上的概率会更大，因为这一定存在了你不知道的一个因素导致了向上的概率大。