1.1.28.删除排序后largeAllowlist中重复的元素

/**
 * ex 1.1.28.删除排序后largeAllowlist中重复的元素
 */
public class BinarySearch {

    public static int rank(int key, int[] a) {
        //数组必须是有序的
        int lo = 0;
        int hi = a.length - 1;

        while(lo <= hi) {

            int mid = lo + (hi - lo) / 2;

            if(key < a[mid]) {
                hi = mid - 1;
            } else if (key > a[mid]) {
                lo = mid + 1;
            } else {
                return mid;
            }
        }

        return -1;
    }

    public static void main(String[] args) {

        String whitelargePath = "/largeAllowlist.txt";
        String whiteTinyPath = "/tinyAllowlist.txt";
        int[] whitelist = new In(whitelargePath).readAllInts();
        Arrays.sort(whitelist);
        String tinyTextPath = "/largeText.txt";
        NewStdIn.readFile(tinyTextPath);

        while(!NewStdIn.isEmpty()) {

            int key = NewStdIn.readInt();

            if(rank(key, whitelist) < 0) {
                StdOut.println(key);
            }
        }
    }
}

1.1.35 模拟投骰子

/**
 *
 */
public class Probability {

    int SIDES = 6;

    int N = 10000000;

    private double[] DIST = null;

    /**
     * 执行多少次可以使用的频率计算出的概率接近真实概率的3个小数点,答案是10000000
     */
    @Test
    public void work() {

        int[] numbers = new int[2*SIDES + 1];
        double[] dist = new double[2*SIDES + 1];

        for(int i=0; i<N; i++) {
            int first = StdRandom.uniform(1, 7);
            int second = StdRandom.uniform(1, 7);
            numbers[first+second] += 1;
        }

        for(int i=0; i<dist.length; i++) {
            dist[i] = Double.valueOf(numbers[i]) / N;
        }

        System.out.println(Arrays.toString(dist));
    }

    /**
     * 这里的dist[i]就是两次筛子之和为i的概率
     */
    @Before
    public void init() {

        double[] dist = new double[2*SIDES + 1];

        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;
        }

        DIST = dist;
        System.out.println(Arrays.toString(DIST));
    }
}

�1.1.36 乱序检查

public class RandomMatch {

    private int T = 10000;

    private int N = Double.valueOf(Math.pow(10, 3)).intValue();

    public int[] getArray() {

        int[] array = new int[N];

        for(int i=0; i<array.length; i++) {
            array[i] = StdRandom.uniform(100000, 1000000);
        }

        return array;
    }

    @Test
    public void work() {

        int count = 0;

        for(int i=0; i<T; i++) {

            int[] array1 = getArray();
            int[] array2 = getArray();

            for(int j=0; j<array1.length; j++) {

                int rank = BinarySearch.rank(array1[j], array2);

                if(rank != -1) {
                    count++;
                }
            }
        }

        System.out.println(count);
    }
}

1.1.39 随机匹配

public class Shuffle {

    private int M = 5;

    private int N = 5;

    @Test
    public void work() {
        //对于列j,行i表示的是i在打乱后落到j的位置的次数。数组中所有的元素都应该接近于N/M
        double[][] mm = new double[M][M];
        //打乱N次
        for (int j=0; j<N; j++) {

            double[] a = initDoubleArray(null);
            shuffle(a);

            for (int i=0; i<M; i++) {

                for (int k=0; k<M; k++) {
                    //列i和a[k]的值标识位置
                    if (i == a[k]) {

                        mm[i][k] += 1;
                    }
                }
            }
        }

        for(int i=0; i<mm.length; i++) {
            System.out.println(Arrays.toString(mm[i]));
        }
    }

    /**
     * 初始化数组
     * @param a
     * @return
     */
    public double[] initDoubleArray(double[] a) {

        if(a == null) {
            a = new double[M];
        }

        for(int i=0; i<a.length; i++) {
            a[i] = Double.valueOf(i);
        }

        return a;
    }

    /**
     * 随机打乱数组a
     * @param a
     */
    public static void shuffle(double[] a) {

        int N = a.length;

        for(int i=0; i<N; i++) {
            //将a[i]和a[i,..,N-1]中任意一个元素交换
            int r = i + StdRandom.uniform(N-i);
            double temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }
}

​