Return to Answer

The conceptually simplest solution would be to create a list where each element occurs as many times as its weight, so

fruits = [apple, apple, apple, apple, orange, orange, lemon]

Then use whatever functions you have at your disposal to pick a random element from that list (e.g. generate a random index within the proper range). This is of course not very memory efficient and requires integer weights.

Another, slightly more complicated approach would look like this:

1. Calculate the cumulative sums of weights:

   intervals = [4, 6, 7]
   

Where an index of below 4 represents an apple, 4 to below 6 an orange and 6 to below 7 a lemon.

2. Generate a random number n in the range of 0 to sum(weights).
3. Go through the list of cumulative sums from start to finish to find the first item whose cumulative sum is above n. The corresponding fruit is your result.

This approach requires more complicated code than the first, but less memory and computation and supports floating-point weights.

For either algorithm, the setup-step can be done once for an arbitrary number of random selections.

The conceptually simplest solution would be to create a list where each element occurs as many times as its weight, so

fruits = [apple, apple, apple, apple, orange, orange, lemon]

Then use whatever functions you have at your disposal to pick a random element from that list (e.g. generate a random index within the proper range). This is of course not very memory efficient and requires integer weights.

Another, slightly more complicated approach would look like this:

1. Calculate the cumulative sums of weights:

   intervals = [4, 6, 7]
   

Where an index of below 4 represents an apple, 4 to below 6 an orange and 6 to below 7 a lemon.

2. Generate a random number n in the range of 0 to sum(weights).
3. Go through the list of cumulative sums from start to finish to find the first item whose cumulative sum is above n. The corresponding fruit is your result.

This approach requires more complicated code than the first, but less memory and computation and supports floating-point weights.

For either algorithm, the setup-step can be done once for an arbitrary number of random selections.

The conceptually simplest solution would be to create a list where each element occurs as many times as its weight, so

fruits = [apple, apple, apple, apple, orange, orange, lemon]

Then use whatever functions you have at your disposal to pick a random element from that list (e.g. generate a random index within the proper range). This is of course not very memory efficient and requires integer weights.

Another, slightly more complicated approach would look like this:

1. Calculate the cumulative sums of weights:

   intervals = [4, 6, 7]
   

Where an index of below 4 represents an apple, 4 to below 6 an orange and 6 to below 7 a lemon.

2. Generate a random number n in the range of 0 to sum(weights).
3. Find the last item whose cumulative sum is above n. The corresponding fruit is your result.

This approach requires more complicated code than the first, but less memory and computation and supports floating-point weights.

For either algorithm, the setup-step can be done once for an arbitrary number of random selections.

The conceptually simplest solution would be to create a list where each element occurs as many times as its weight, so

fruits = [apple, apple, apple, apple, orange, orange, lemon]

Then use whatever functions you have at your disposal to pick a random element from that list (e.g. generate a random index within the proper range). This is of course not very memory efficient and requires integer weights.

Another, slightly more complicated approach would look like this:

1. Calculate the cumulative sums of weights:

   intervals = [4, 6, 7]
   

Where an index of below 4 represents an apple, 4 to below 6 an orange and 6 to below 7 a lemon.

2. Generate a random number n in the range of 0 to sum(weights).
3. Go through the list of cumulative sums from start to finish to find the first item whose cumulative sum is above n. The corresponding fruit is your result.

This approach requires more complicated code than the first, but less memory and computation and supports floating-point weights.

For either algorithm, the setup-step can be done once for an arbitrary number of random selections.

The simplest solution would be to create a list where each element occurs as many times as its weight, so

fruits = [apple, apple, apple, apple, orange, orange, lemon]

Then use whatever functions you have at your disposal to pick a random element from that list (e.g. generate a random index within the proper range). This is of course not very memory efficient and requires integer weights.

Another, slightly more complicated approach would look like this:

1. Prepare a list of intervals that cover 0 to sum(weights). Each interval represents one fruit, its length being the weight of this fruit, so for your example:

   intervals = [3, 5, 6]
   

Where an index of 0-3 represents an apple, 4-5 an orange and 6 a lemon.

2. Generate a random number n in the range of 0 to sum(weights)
3. Find the interval in which n falls and you got your fruit.

This approach requires more processing power than the first, but less memory and supports floating point weights.

The conceptually simplest solution would be to create a list where each element occurs as many times as its weight, so

fruits = [apple, apple, apple, apple, orange, orange, lemon]

Then use whatever functions you have at your disposal to pick a random element from that list (e.g. generate a random index within the proper range). This is of course not very memory efficient and requires integer weights.

Another, slightly more complicated approach would look like this:

1. Calculate the cumulative sums of weights:

   intervals = [4, 6, 7]
   

Where an index of below 4 represents an apple, 4 to below 6 an orange and 6 to below 7 a lemon.

2. Generate a random number n in the range of 0 to sum(weights).
3. Find the last item whose cumulative sum is above n. The corresponding fruit is your result.

This approach requires more complicated code than the first, but less memory and computation and supports floating-point weights.

For either algorithm, the setup-step can be done once for an arbitrary number of random selections.