How to compute the "15% of the time" randomness?

I'm looking for a decent, elegant method of calc开发者_C百科ulating this simple logic.

Right now I can't think of one, it's spinning my head.

I am required to do some action only 15% of the time.

I'm used to "50% of the time" where I just mod the milliseconds of the current time and see if it's odd or even, but I don't think that's elegant.

How would I elegantly calculate "15% of the time"? Random number generator maybe?

Pseudo-code or any language are welcome.

Hope this is not subjective, since I'm looking for the "smartest" short-hand method of doing that.

Thanks.

Solution 1 (double)

• get a random double between 0 and 1 (whatever language you use, there must be such a function)
• do the action only if it is smaller than 0.15

Solution 2 (int)

You can also achieve this by creating a random int and see if it is dividable to 6 or 7. UPDATE --> This is not optimal.

You can produce a random number between 0 and 99, and check if it's less than 15:

if (rnd.Next(100) < 15) ...

You can also reduce the numbers, as 15/100 is the same as 3/20:

if (rnd.Next(20) < 3) ...

Random number generator would give you the best randomness. Generate a random between 0 and 1, test for < 0.15.

Using the time like that isn't true random, as it's influenced by processing time. If a task takes less than 1 millisecond to run, then the next random choice will be the same one.

That said, if you do want to use the millisecond-based method, do milliseconds % 20 < 3.

Just use a PRNG. Like always, it's a performance v. accuracy trade-off. I think making your own doing directly off the time is a waste of time (pun intended). You'll probably get biasing effects even worse than a run of the mill linear congruential generator.

In Java, I would use nextInt:

myRNG.nextInt(100) < 15

Or (mostly) equivalently:

myRNG.nextInt(20) < 3

There are way to get a random integer in other languages (multiple ways actually, depending how accurate it has to be).

Using modulo arithmetic you can easily do something every Xth run like so

(6 will give you ruthly 15%

if( microtime() % 6 === ) do it

other thing:

if(rand(0,1) >= 0.15) do it

boolean array[100] = {true:first 15, false:rest};
shuffle(array);
while(array.size > 0)
{
    // pop first element of the array.
    if(element == true)
       do_action();
    else
       do_something_else();
}
// redo the whole thing again when no elements are left.

Here's one approach that combines randomness and a guarantee that eventually you get a positive outcome in a predictable range:

Have a target (15 in your case), a counter (initialized to 0), and a flag (initialized to false).

Accept a request.
If the counter is 15, reset the counter and the flag.
If the flag is true, return negative outcome.
Get a random true or false based on one of the methods described in other answers, but use a probability of 1/(15-counter). 
Increment counter
If result is true, set flag to true and return a positive outcome. Else return a negative outcome.
Accept next request

This means that the first request has probability of 1/15 of return positive, but by the 15th request, if no positive result has been returned, there's a probability of 1/1 of a positive result.

This quote is from a great article about how to use a random number generator:

Note: Do NOT use

  y = rand()  %  M;

as this focuses on the lower bits of rand(). For linear congruential random number generators, which rand() often is, the lower bytes are much less random than the higher bytes. In fact the lowest bit cycles between 0 and 1. Thus rand() may cycle between even and odd (try it out). Note rand() does not have to be a linear congruential random number generator. It's perfectly permissible for it to be something better which does not have this problem.

and it contains formulas and pseudo-code for

• r = [0,1) = {r: 0 <= r < 1} real
• x = [0,M) = {x: 0 <= x < M} real
• y = [0,M) = {y: 0 <= y < M} integer
• z = [1,M] = {z: 1 <= z <= M} integer