如何生成 0 到 9 之间的 1000 个随机数？

Question

如何使用用户提供的值生成 0 到 9 之间的 1000 个随机数？

1. 程序需要允许用户选择事实的值， 常数、模数和起始种子数。

2. 它应该使用这些值生成 0 到 9 之间的 1000 个随机数。

3. 将每个数字生成的次数存储在一个数组中。

4. 最后输出数字的分布。

这是我到目前为止所做的，但我直到现在才让用户输入信息，所以，我离达到第 2、3 和 4 名还很远。

public static void main(String[] args) {
    int fact;
    int constant;
    int modulus;
    int seednumber;

    Scanner scan = new Scanner(System.in);
    System.out.println("Input Fact: ");
    fact = scan.nextInt();

    System.out.println("Input Const: ");
    constant = scan.nextInt();

    System.out.println("Input M: ");
    modulus = scan.nextInt();

    System.out.println("Input Seed: ");
    seednumber = scan.nextInt();

    int [] arrayBox;
    arrayBox = new int [10];
    for (int i=0; i<10; i++){
        arrayBox[i]=0;
      }

    int noOfNumberGenerated=0;
    while (noOfNumberGenerated<1000){
        seednumber=(((fact*seednumber)+constant)%modulus);
}

Answer 1

如果您打算使用 Random 类，则不需要所有这些输入参数。您只需要一个长种子和用于生成的模数（如果需要，还需要生成的数量）：

import java.util.*;

public class RandomNumbers {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("Input Long Seed: ");
        long seed = scan.nextLong();

        System.out.println("Input Modulus: ");
        int modulus = scan.nextInt();

        System.out.println("Number of Iterations: ");
        int iterations = scan.nextInt();

        int[] arrayBox =new int[modulus];

        Random random = new Random(seed);

        for (int i=0;i<iterations;i++){
            arrayBox[random.nextInt(modulus)]++;
        }

        for (int i=0; i<modulus; i++){
            System.out.println("arrayBox["+i+"]="+arrayBox[i]);
        }
    }
}

Answer 2

首先这部分不需要：

for (int i=0; i<10; i++){
        arrayBox[i]=0;
}

默认情况下，该数组将由 0 填充。

对于第 2 部分和第 3 部分：

Random randomGenerator = new Random(seed);
for (int idx = 0; idx < 1000; idx++){
  int randomInt = randomGenerator.nextInt(10);
  arrayBox[randomInt] = arrayBox[randomInt] + 1
}   

第四部分：

for(int i =0; i< 10; i++){
   System.out.println("amount of "+i+" is "+arrayBox[i]);
}

--编辑-- 作为对您评论的回应，Java 中的 Random 类本身就是 LGC 的实现，被认为是更好的类之一。常量被硬编码为

fact = 25214903917
constant = 11

这些数字是经过大量测试后选择的，我相信您可以在互联网上找到很多关于它的文档。

在您的情况下，您有 2 个选项。强制Random 使用您的常量或自己编写。选项 1 将为您提供 Random 类的较弱版本，但仍将比选项 2“更强”。

对于 1：

public class RandomCustom extends Random{

    //You have to Override this aswell.
    @Override
    synchronized public void setSeed(long seed) {
        this.seed.set(initialScramble(seed));
        haveNextNextGaussian = false;
    }

    @Override
    protected int next(int bits){
        long oldseed, nextseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            nextseed = (oldseed * fact + constant) & modulus;
        } while (!seed.compareAndSet(oldseed, nextseed));
        return (int)(nextseed >>> (48 - bits));
    }
}

在此之后，只需从 RandomCustom 顶部的代码更改 Random 即可。

在我看来，为什么要尝试重新发明轮子，而不是使用已被证明可靠且有效的东西