【算法】模拟掷骰子

模拟掷骰子。以下代码能够计算每种两个骰子之和的准确概率分布：

int SIDES = 6;
double[] dist = new double[2*SIDES+1];
for (int i = 1; i <= SIDES; i++) 
    for (int j = 1; i <= SIDES; j++)
        dist[i+j] += 1.0;

for (int k = 2; k <= 2*SIDES; k++)
    dist[k] /= 36.0;

 dist[i] 的值就是两个骰子之和为i的概率。用实验模拟N次掷骰子，并在计算两个1到

 6之间的随机整数之和时记录每个值的出现频率以验证它们的概率。N要多大才能够保证你

 的经验数据和准确数据的吻合程度达到小数点后三位？

实验代码：

package com.beyond.algs4.experiment;

import java.math.BigDecimal;

import com.beyond.algs4.lib.StdRandom;


public class Sides {

    private static int SIDES = 6;
    
    private double[] dist = new double[2*SIDES + 1];
    
    public double[] getDist() {
        return dist;
    }

    public void setDist(double[] dist) {
        this.dist = dist;
    }

    public void probability() {
        for (int i = 1; i <= SIDES; i++) {
           for (int j = 1; j <= SIDES; j++) {
               dist[i + j] += 1.0;
           } 
        }
        for (int k = 2; k <= 2*SIDES; k++) {
            dist[k] /= 36.0;
        }
    }
    
    public void print() {
        for (int i = 0; i < dist.length; i++) {
            System.out.println(
                    String.format("Probability of [%d] is: %f", i, dist[i]));
        }
    }
    
    public static class Emulator {
        private int N = 100;
        
        private double[] dist = new double[2*SIDES + 1];
        
        public int getN() {
            return N;
        }

        public void setN(int n) {
            N = n;
        }

        public double[] getDist() {
            return dist;
        }

        public void setDist(double[] dist) {
            this.dist = dist;
        }

        public void emulator() {
            for (int i = 0; i < N; i++) {
                int a = StdRandom.uniform(1, 7);
                int b = StdRandom.uniform(1, 7);
                dist[a + b] += 1.0;
            }
            for (int k = 2; k <= 2*SIDES; k++) {
                dist[k] /= N;
            }
        }        
        
        public int n(Sides sides) {
            for (int i = 1; i <= 100; i++) {
                this.setN(new Double(Math.pow(10, i)).intValue() * this.N);
                this.emulator();
                boolean appr = true;
                for (int k = 2; k <= 2*SIDES; k++) {
                    double s = this.getDist()[k];
                    BigDecimal bs = new BigDecimal(s);
                    double s1 = bs.setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
                    double t = sides.getDist()[k];
                    BigDecimal bt = new BigDecimal(t);
                    double t1 = bt.setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
                    if (s1 != t1) {
                        appr = false;
                        break;
                    }
                }
                if (appr) {
                    return this.getN();   
                }
            }
            return 0;
        }
        
        public void print() {
            for (int i = 0; i < dist.length; i++) {
                System.out.println(
                        String.format("Probability of [%d] is: %f", i, dist[i]));
            }
        }
        
        
    }
    
    public static void main(String[] args) {
        Sides sides = new Sides();
        sides.probability();

        Emulator e = new Emulator();
        int N = e.n(sides);
        System.out.println(String.format("The N is: %d", N));
        System.out.println("Actual: ");
        sides.print();
        System.out.println("Experiment: ");
        e.print();
    }

}

实验结果：

The N is: 100000000
Actual: 
Probability of [0] is: 0.000000
Probability of [1] is: 0.000000
Probability of [2] is: 0.027778
Probability of [3] is: 0.055556
Probability of [4] is: 0.083333
Probability of [5] is: 0.111111
Probability of [6] is: 0.138889
Probability of [7] is: 0.166667
Probability of [8] is: 0.138889
Probability of [9] is: 0.111111
Probability of [10] is: 0.083333
Probability of [11] is: 0.055556
Probability of [12] is: 0.027778
Experiment: 
Probability of [0] is: 0.000000
Probability of [1] is: 0.000000
Probability of [2] is: 0.027754
Probability of [3] is: 0.055544
Probability of [4] is: 0.083374
Probability of [5] is: 0.111130
Probability of [6] is: 0.138897
Probability of [7] is: 0.166751
Probability of [8] is: 0.138832
Probability of [9] is: 0.111088
Probability of [10] is: 0.083306
Probability of [11] is: 0.055517
Probability of [12] is: 0.027807

结果分析：
多次运行，N值一般为100000000，也有不稳定的时候是其他数值。

补充说明：

1. 以N=100为初始值，循环执行计算模拟N次的概率情况，如果吻合度不满足则N以10倍递增直至找到合适的N值。（有待改进，采用while（find））

2. “吻合程度达到小数点后三位”的实现方式采用小数点后三位ROUND_DOWN的方式，有待改进

3. N值并非每次运行皆为100000000的稳定结果，可适当随机多次执行，以分析N值的分布情况

参考资料：

算法 第四版  谢路云 译 Algorithms Fourth Edition [美] Robert Sedgewick, Kevin Wayne著

http://algs4.cs.princeton.edu/home/

源码下载链接：

http://pan.baidu.com/s/1c0jO8DU