Archive for Random

Random Numbers – shuffling (and $300 Million)

Posted in Programming with tags , , on November 17, 2006 by wsjoung

$300 Million, is this enough amount of money for a good tiny program?
of course it is!
Well, current estimated jackpot is $300 million for this Saturday. oh my god! huh?
okay then, let make a tiny program to get me a luck.
– This is my idea.
1. I need to generate five random numbers form 1 to 55 without repeat.
2. another number from 1 to 42 independently.
int powerBall = generator.nextInt(42)+1;
3. open a text file of past winning numbers and, count those numbers.
4. add weight to generate random numbers based on the past winning numbers.

To implement, I think shuffling array would be the most easiest way.

int[] numbers = new int[55];
int length = numbers.length;

for (int i=0; i < length ; i++)
numbers[i] = i+1;

for (int i=0; i < length; i++) {
int position = generator.nextInt(length);
int tmp = numbers[i];
numbers[i] = numbers[position];
numbers[position] = tmp;

then we can pick 5 of them. with our lucky algorithm.

good luck!!

Past winning numbers

Java Random Numbers

Posted in Programming with tags , , on November 17, 2006 by wsjoung

Java has a rich toolkit for generating random numbers, in a class named “Random”. This document is a quick guide to using Random. Random can generate many kinds of random number, not all of which I discuss here.

The best way to think of class Random is that its instances are random number generator objects — objects that go around spitting out random numbers of various sorts in response to messages from their clients.

Creating Random Number Generators

The easiest way to initialize a random number generator is to use the parameterless constructor, for example

Random generator = new Random();

However, beware of one thing when you use this constructor: Algorithmic random number generators are not truly random, they are really algorithms that generate a fixed but random-looking sequence of numbers. When you create a random number generator, it initializes its sequence from a value called its “seed”. The parameterless constructor for Random uses the current time as a seed, which is usually as good a seed as any other. However, the time is only measured to a resolution of 1 millisecond, so if you create two random number generators within one millisecond of each other, they will both generate exactly the same sequence of numbers.

If you prefer, there is also a constructor for Random that allows you to provide your own seed. You can use any long integer as a seed with this constructor. Note that there is no magic way of picking “good” seeds. For example, the following creates a random number generator with seed 19580427:

Random generator2 = new Random( 19580427 );

Generating Random Integers

To generate a random integer from a Random object, send the object a “nextInt” message. This message takes no parameters, and returns the next integer in the generator’s random sequence. Any Java integer, positive or negative, may be returned. Integers returned by this message are uniformly distributed over the range of Java integers. Here is an example, assuming that “generator” is an instance of Random:

int r = generator.nextInt();

Often, programmers want to generate random integers between 0 and some upper bound. For example, perhaps you want to randomly pick an index into an array of n elements. Indices to this array, in Java, range from 0 to n-1. There is a variation on the “nextInt” message that makes it easy to do this: If you provide an integer parameter to “nextInt”, it will return an integer from a uniform distribution between 0 and one less than the parameter. For example, here is how you could use a random number generator object to generate the random array index suggested a minute ago:

int randomIndex = generator.nextInt( n );

Generating Random Real Numbers

Random number generators can also generate real numbers. There are several ways to do so, depending on what probablity distribution you want the numbers drawn from.

To generate a random real number uniformly distributed between 0 and 1, use the “nextDouble” message. This message takes no parameters. For example…

double r = generator.nextDouble();

To generate a random number from a normal distribution, use “nextGaussian”. This message takes no parameters and returns a random number from a normal distribution with mean 0 and standard deviation 1. In layman’s terms, this means that the results may be either positive or negative, with both being equally likely; the numbers will almost always have small absolute values (about 70% will lie between -1 and 1, about 95% between -2 and 2). For example…

double r = generator.nextGaussian();

Translating and Scaling Random Numbers

Random number generators often return numbers in some limited range, typically 0 to b for some upper bound b. Sometimes you need your random numbers to lie in a different range. You can make random numbers lie in a longer or shorter range by multiplying them by a scale factor (scaling). You can make random numbers lie in a range that is shifted to higher or lower numbers than the original by adding (or subtracting) an offset from the random numbers (translating).

Here are some examples of these operations:

* Suppose you are writing a game program that simulates throwing dice, and so need a random integer in the range 1 to 6. “nextInt” can give you one in the range 0 to 5, and you can translate this to the range you need:

int throw = generator.nextInt(6) + 1;

* In drawing a pattern made up of random lines, you want to pick a random angle between 0 and 360 degrees at which to draw a line. The angle can be any real number. The “nextDouble” message will give you a random real number, but between 0 and 1. You can use scaling to turn this into a real number between 0 and 360:

double angle = generator.nextDouble() * 360.0;

* Suppose the same pattern-drawing program also needs to pick random lengths for the lines, but that the lines should never be shorter than 10 units, nor longer than 50. Line lengths can be any real number between these limits. Thus you need random lengths from a 40-unit range starting at 10. You can use scaling and translation together to generate these numbers from “nextDouble”:

double length = generator.nextDouble() * 40.0 + 10.0;

Random Numbers in Java by Doug Baldwin