java中生成特定随机数的概率

Question

If I have a random number generator that generates numbers 0-1, is there a way that I can increase the probability of it generating certain numbers? Say that the values .5+ on the random number generator are equal to the color blue and numbers lower are equal to red. Can I make it so that the user can enter a number as a percentage in order to increase/decrease the likelihood of generating the color red?

Answer 1

From your question it sounds like you're working with Math.random() .

Stop doing that; modifying the 0-1 range to a uniform selection of limited choices, for example by:

int fairDie = 1 + (int) (Math.random() * 6)

Because that is not truly fair.

Instead, use this:

Random r = new Random(); // do this only once for the app.
int fairDie = 1 + r.nextInt(6);

The above is truly fair.

If you want to pick from a limited selection and want some in the selection to occur more often, the simplest way is to make a list of the choices, duplicating entries as much as you need to get to the right odds. For example, if the choices are red, green, and blue, and they are to be chosen in a 1:2:3 arrangement, try:

List<String> colors = new ArrayList<String>(List.of("red", "green", "green", "blue", "blue", "blue"));
Collections.shuffle(colors);
System.out.println("Chosen: " + colors.get(0));

This uses shuffle, which under the hood uses the proper kind of random (it's fair and uniform). Another option is to simply create ranges: [0-1) is red, [1, 3) is green, [3, 6) is blue, and then rnd.nextInt(6) .

wait, why is that 'unfair'?

We can prove this with the pigeon hole principle.

Math.random() returns a double. A computer is not magical; doubles are represented by 64 bits, and because math, that can represent at most 2^64 different numbers. That's a lot of numbers, but it gets down to a little less because doubles can also represent numbers outside of the 0-1 range, but Math.random() will never return them.

The key is, there is a limited amount of numbers that Math.random() could possibly return. It's a very large number to be sure, but limited. Let's say it's 1239235915810453815 different options.

And you want to fairly choose from between 6 options, uniformly.

The problem is, 6 does not evenly divide into 1239235915810453815. That means it is impossible to do this fairly. Imagine that Math.random() returns 9 different numbers, and you're using this to roll a fair die. Well, 6 of those 9 go for 1-6 on the die, and the remaining 3 go to.. what? 2, 4, and 6? Now 2/4/6 are twice as likely as 1/3/5. You can't get to a fair result.

rnd.nextInt(5) addresses this and guarantees fairness, which is why you should use it.