Re: DO WHILE
Thomas A. Russ wrote:
Another somewhat clever method would be to do something like this:
final static int N_BALLS = 42;
final static int N_DRAWS = 6;
Random generator = new Random();
Collection<Integer> balls = new HashSet<Integer>(N_BALLS);
Collection<Integer> choices = new ArrayList<Integer>(N_DRAWS);
for (int i = 0; i < N_BALLS; i++) {
balls[i] = i+1;
^
This line will not compile. You can't use array notation on a Collection type
like that, and you can't index a Set anyway, much less a Collection.
}
int range = N_BALLS;
for (int j = 0; j < N_DRAWS; j++) {
choices[j] = balls[generator.nextInt(range--)];
^ ^
Same problems, except at least you can index a List, but not, alas, a
Collection. You'd need to declare the variable 'List' to index it.
This is an area where the advice to use
<http://sscce.org/>
comes in. It helps, even if you don't publish whole examples, to run them
before citing snippets. That said, I often don't run snippets I publish here,
and nearly as often get corrected for some grammatical or stupider error in my
code.
But it helps at least to make the attempt to make your snippets valid Java
fragments, and I suggest putting comment markers in places where you
intentionally deviate:
public class Foo
{
// ... put stuff here - uncommented, this line is not compilable
}
balls.remove(choices[j]);
}
I suspect you intended something like this uncompiled, untested code:
public class Lottu
{
private static final int N_BALLS = 42;
private static final int N_DRAWS = 6;
private final Random generator = new Random();
public List <Integer> chooseBalls()
{
List <Integer> choices = new ArrayList <Integer> (N_DRAWS);
List <Integer> balls = new ArrayList <Integer> (N_BALLS);
for( int b = 0; b < N_BALLS; b++ )
{
balls.add( b+1 );
}
for ( int d = 0; d < N_DRAWS; d++ )
{
final int chx = generator.nextInt( balls.size() );
choices.add( balls.get( chx );
balls.remove( chx );
}
return choices;
}
}
Also you can implement the method as:
public List <Integer> chooseBalls()
{
List <Integer> balls = new ArrayList <Integer> (N_BALLS);
for( int b = 1; b <= N_BALLS; b++ )
{
balls.add( b );
}
Collections.shuffle( balls, generator );
List <Integer> choices = new ArrayList <Integer> (N_DRAWS);
Iterator <Integer> bait = balls.iterator();
for ( int d = 0; d < N_DRAWS; d++ )
{
choices.add( bait.next() );
}
return choices;
}
You're costing a shuffle of length N_BALLS instead of length N_DRAWS, but
you're benefiting by the elimination of N_DRAWS removals of average length
near (N_BALLS/2 - N_DRAWS/4). That's a little less than N_DRAWS/2 full scans
of the 'balls' list regained at the cost of one.
--
Lew