[Solved] JAVA – How do I generate a random number that is weighted towards certain numbers? [duplicate]

Introduction

Generating random numbers is a common task in programming, and it can be useful for a variety of applications. However, sometimes it is desirable to generate random numbers that are weighted towards certain numbers. This can be useful for creating a more realistic random distribution, or for creating a game with a higher chance of certain outcomes. In this article, we will discuss how to generate a random number that is weighted towards certain numbers using Java. We will discuss the different methods available, and provide examples of how to use them.

Solution

The following code snippet can be used to generate a random number that is weighted towards certain numbers:

// Create an array of weights
int[] weights = {1, 2, 3, 4, 5};

// Create a random number generator
Random rand = new Random();

// Generate a random number between 0 and the sum of the weights
int totalWeight = 0;
for (int weight : weights) {
totalWeight += weight;
}
int randomNumber = rand.nextInt(totalWeight);

// Find the index of the weight that the random number falls into
int index = 0;
int cumulativeWeight = 0;
for (int weight : weights) {
cumulativeWeight += weight;
if (randomNumber < cumulativeWeight) { break; } index++; } // The index is the weighted random number int weightedRandomNumber = index;

public static void main(String[] args){
    ArrayList<Integer> list = new ArrayList<Integer>();
    list.add(5);list.add(2);// to be continued ...        
    int randomInt = list.get((int) (Math.random() * list.size()));
    System.out.println(randomInt);
}

Generating a random number that is weighted towards certain numbers can be done in Java using the Random class. The Random class provides a method called nextInt(int n) which returns a random integer between 0 (inclusive) and the specified value (exclusive). To generate a random number that is weighted towards certain numbers, you can use the following approach:

1. Create an array of integers that represent the weights of the numbers you want to generate.
2. Create a new array that contains the cumulative sum of the weights.
3. Generate a random number between 0 and the sum of the weights.
4. Use a binary search to find the index of the random number in the cumulative sum array.
5. Return the number at the index of the cumulative sum array.

For example, if you want to generate a random number that is weighted towards the numbers 1, 2, and 3, with weights of 0.2, 0.3, and 0.5 respectively, you can use the following code:

int[] weights = {0.2, 0.3, 0.5};
int[] cumulativeSum = new int[weights.length];
cumulativeSum[0] = weights[0];
for (int i = 1; i < weights.length; i++) {
    cumulativeSum[i] = cumulativeSum[i - 1] + weights[i];
}

Random random = new Random();
int randomNumber = random.nextInt(cumulativeSum[cumulativeSum.length - 1]);
int index = Arrays.binarySearch(cumulativeSum, randomNumber);
if (index < 0) {
    index = Math.abs(index + 1);
}
int number = index + 1;

In this example, the random number generated will be 1, 2, or 3 with the specified weights.