I am no statistician, so this is more a question than a strategy,
but woul it not be just as valid to have a Vector of
'number of values in lottery' and simply remove any number
that comes up?

E.G.  start with a vector of 49 elements, if '35' is first
chosen, remove that element and choose randomly
from the the remaining 48 elements.

And please change 'tab's to a couple of spaces before posting,
that line is this wide...
                              Date today=new Date();
..in my 'news client'.

Andrew T.

 No, this lottery in fact is located here in Germany, and it's
 called "6 aus 49".

 Actually the numbers are best, which are most rarely chosen
 by other players, because then the rates will be higher.

 Destructive criticism is much more fun!

class NumericMapUtils
{ public static <D> void addTo
 ( final java.util.Map<D,java.lang.Integer> map, final D d, final int i )
 { map.put( d, i +( map.containsKey( d )? map.get( d ): 0 )); }}

public class Main
{ static final java.util.Random rand = new java.util.Random();
 public static void main( java.lang.String[] args )
 { final java.util.Map<java.lang.Integer,java.lang.Integer> map
   = new java.util.HashMap<java.lang.Integer,java.lang.Integer>( 50 );
   for( int i = 0; i < 1000; ++i )
   NumericMapUtils.<java.lang.Integer>addTo( map, rand.nextInt( 49 ), 1 );
   final java.util.SortedMap<java.lang.Integer,java.lang.Integer> sort
   = new java.util.TreeMap<java.lang.Integer,java.lang.Integer>();
   for( final java.lang.Integer i : map.keySet() )sort.put( -map.get( i ), i );
   int c = 0; for( final int i : sort.keySet() )
   { java.lang.System.out.println
     ( "Rank " +( c + 1 )+ " number is " + sort.get( i ));
     if( ++c >= 6 )break; }}}

Rank 1 number is 21
Rank 2 number is 14
Rank 3 number is 34
Rank 4 number is 15
Rank 5 number is 47
Rank 6 number is 20

 However, there is a small chance that »nextInt« will return
 the same number for 1000 times, so that the program would only
 output one number; but I tried to implement your general
 description.

[snip]

If you're asking this just as a Java question, then there are certainly
things you can do to improve on it. But I have to point out that you're
not modelling the real world here. You'll mostly be testing for bias in
the Java random number generator, when you should really be testing for
bias in whatever process/equipment the lottery agency is using.

If they keep historical records for downloading (as our Australian
agency does), you'd be better served to download that and massage it.

Cheers,
Luke

You are assuming that any bias in the Java Random class also applies to
the lottery's random number generation method? I suspect it is using
genuinely random numbers, not just pseudo-random, and monitors them for
bias.

Here is an alternative method for picking the 6 numbers.

There is a well-known linear time algorithm for shuffling an array, the
Fisher-Yates shuffle. On iteration i, the element with index i is
swapped with a randomly selected element between i and the end of the array.

There are two important loop invariants:

1. At the end of every iteration, the array contains a permutation
of its original contents.

2. After N iterations, the first N elements of the array are randomly
selected with equal probability.

In a normal shuffle, the number of iterations is equal to the size of
the array minus one, and all elements have been shuffled. (The last
iteration is not needed because it makes a random choice from one
element, and swaps that element with itself).

Why not run Fisher-Yates for 6 iterations, and then pick up the
first 6 elements of the array?

Patricia

  /**
   * Partially shuffle the elements of an int
   * array
   *
   * On completion, data contains a permutation of
   * its original contents, with the elements in
   * the first count spaces selected randomly.
   * There is no assurance of randomness for
   * elements data[count] and later, and many of
   * those elements may remain in their original
   * positions.
   *
   * @param data
   *          The array
   * @param count
   *          The number of elements to shuffle.
   *          If count is negative or greater than
   *          data.length, all elements are
   *          shuffled.
   * @param rand
   *          partialShuffle gets its random
   *          numbers from this generator.
   */
  public static void partialShuffle(int[] data, int count,
      Random rand) {
    if (count > data.length || count < 0) {
      count = data.length;
    }
    for (int i = 0; i < count; i++) {
      int pickIndex = rand.nextInt(data.length - i) + i;
      int temp = data[pickIndex];
      data[pickIndex] = data[i];
      data[i] = temp;
    }
  }

This requires analysis, not code.

  BugBear

 snipped

ok, to be brutal - you have created a Procedural solution not an Object
Oriented solution.  Given that Java is aimed at being an OO language
(lets not get into an argument about what that is nor Java's flaws) it
would be good to see the solution using the tools and techniques from an
OO perspective.

That said, even if we stick with a procedural solution your current one
needs a lot of work to improve its readability (never mind logic changes
to remove unneeded loops, conditions or state)

HTH

Andrew...........

A simple starting point would be to turn comments into executable comments.

For example,

 // the original array of 6 numbers picked
 int [] list = new int[6];
 // the new array containing unique numbers only
 int[] newList = new int[6];
 // this array is used to count the number of occurances (1-49)
 int [] BigList = new int[50];

becomes something like...

 int [] originalPickedNumbers = new int[6];
 int [] uniqueNumbers = new int[6];
 int [] numberOfOccurancesCount = new int[50];

Another example would be for each of those comments blocks to become
method names and move the code they refer to, into these new methods.

for example....

public class Sample {

  public static void main(String args[]) {
    Date today = new Date();
    System.out.println("Starting:" + today);

    //the original array of 6 numbers picked
    int[] list = new int[6];
    //the new array containing unique numbers only
    int[] newList = new int[6];
    int number = 0;
    //this array is used to count the number of occurances (1-49)
    int[] BigList = new int[50];

    initializeBigList(BigList);
    //do this whole thing a million times
    for (int y = 1; y <= 1000000; y++) {
      initializeNewList(newList);
      put6RandomNumbersIntoAnArray(list);
      boolean dupLocated = copyAllUniqueNumbersIntoNewList(list, newList);

      if (dupLocated) {
        replaceAnyZeroSpaceHolderWithRandomNumber(newList);
      }

      incrementBigListValuesThatMatchEachOfTheSixNumbers(list, BigList);
    }

    int[] topSix = createNewListContainingOnlyTopSix(BigList);
    printListOfTopSix(topSix);
  }

  private static void printListOfTopSix(int[] topSix) {
    //now print out the list of topSix
    for (int i = 0; i <= topSix.length - 1; i++)
      System.out.println("Rank " + (i + 1) + " number is " + topSix[i]);
    Date today2 = new Date();
    System.out.println("Ending:" + today2);
  }

  private static int[] createNewListContainingOnlyTopSix(int[] BigList) {
    //now find the top six and create a new array called topSix
    int[] topSix = new int[6];
    for (int count = 0; count <= topSix.length - 1; count++) {
      int lIndex = 0;
      int largest = BigList[0];
      //compare each element of BigList with each "other" element
      //of BigList (I created this algorithm on my own, or maybe I
rememered
      //it from somewhere.
      for (int x = 0; x <= BigList.length - 1; x++) {
        for (int y = x + 1; y <= BigList.length - 2; y++)
          if (BigList[y] > largest) {
            largest = BigList[y];
            BigList[y] = 0;
            lIndex = y;
            topSix[count] = lIndex;
          }

      }
    }
    return topSix;
  }

  private static void
incrementBigListValuesThatMatchEachOfTheSixNumbers(int[] list, int[]
BigList) {
    //so now we have a list of 6 unique numbers. and we need to increment
    //the value in BigList that corresponds to each of the six numbers.
    for (int j = 0; j <= list.length - 1; j++) {
      int idx = list[j];
      BigList[idx]++;
    }
  }

  private static void replaceAnyZeroSpaceHolderWithRandomNumber(int[]
newList) {
    //now that we have at least one duplicate, we need to replace
    //the zero space holder with a new random number. So
    //to do that, we select a random number and then check to see
    //if it is the array. If it isn't then stick in in the list
    //otherwise, keep
    //selecting and checking until we can put it in (usually takes one
ortwo
    //iterations
    for (int x = 0; x <= newList.length - 1; x++)
      if (newList[x] == 0) {
        boolean t = false;
        while (!t) {
          Random rand = new Random();
          int number1 = rand.nextInt(49) + 1;
          int tt = 0;
          for (int r = 0; r <= newList.length - 1; r++)
            if (newList[r] != 0)
              if (newList[r] == number1)
                tt++;
          if (tt == 0) {
            newList[x] = number1;
            t = true;
          }
        }
      }
  }

  private static boolean copyAllUniqueNumbersIntoNewList(int[] list,
int[] newList) {
    //what this loop does is check each member of "list" to see
    //if it's a duplicate. Copy the current element to the newList
    //if it's not a duplicate.
    boolean dupLocated = false;
    for (int b = 0; b <= list.length - 1; b++) {
      int chkNum = list[b];
      int temp = b;
      boolean found = false;
      for (int a = 0; a <= newList.length - 1; a++) {
        if (newList[a] == chkNum) {
          found = true;
          dupLocated = true;
        }
      }
      if (!found)
        newList[temp] = chkNum;
    }
    return dupLocated;
  }

  private static void put6RandomNumbersIntoAnArray(int[] list) {
    int number;
    //put 6 random numbers into an array
    for (int z = 0; z < 6; z++) {
      Random rand = new Random();
      number = rand.nextInt(49) + 1;
      list[z] = number;
    }
  }

  private static void initializeNewList(int[] newList) {
    //initialize newList
    for (int t = 0; t <= newList.length - 1; t++)
      newList[t] = 0;
  }

  private static void initializeBigList(int[] BigList) {
    //initialize BigList
    for (int x = 0; x <= BigList.length - 1; x++)
      BigList[x] = 0;
  }
}

import java.util.ArrayList;
import java.util.Random;
public class SixFourNine {
   ArrayList winningNumbers = null;
   public static int NUM_CHOICES = 6;
   public static int MAX_NUMBER = 49;
   int[][] simulationArray = new int[MAX_NUMBER][2];
   /** creates a new SixFourNine object**/
   public SixFourNine() {
       initializeSimulationArray();
   }
   /** initializes the array for storing the simulation **/
   public void initializeSimulationArray() {
       for (int i=0; i <MAX_NUMBER; i++) {
           simulationArray[i][0] = (i+1);
           simulationArray[i][1] = 0;
       }
   }
   /** default simulation -- 1 million trials **/
   public void runSimulation() {
       runSimulation(1000000);
   }
   /** simulation -- specify # trials **/
   public void runSimulation(int numTrials) {
       if (numTrials <= 0 ) return;
       Random rand = null;
       int number = 0;
       for (int i = 0; i < numTrials; i++ ){
           rand = new Random() ;
           number=rand.nextInt(MAX_NUMBER) + 1;
           simulationArray[number-1][1]++;
       }
   }
   /** get the winning numbers.  throws an exception if you have not
run a simulation **/
   public ArrayList getWinningNumbers() throws
SixFourNineSimulationNotRunException {
       if (simulationArray == null) throw new
SixFourNineSimulationNotRunException();
       winningNumbers = new ArrayList();
       for (int i = 0; i < NUM_CHOICES; i++) {
           Integer r = new Integer(findAndRemoveMax());
           winningNumbers.add(r);
       }
       initializeSimulationArray();
       return winningNumbers /*NOT A GUARANTEE*/;
   }
   /** finds the most picked number from the simulations, in the case
of a tie, largest number (index) wins **/
   private int findAndRemoveMax() {
       int max = 0;
       int count = 0;
       for (int i = 0; i < MAX_NUMBER; i++) {
           if (simulationArray[i][1] > count) {
               count = simulationArray[i][1] ;
               max = i;
           }
       }
       simulationArray[max][1] =0;
       return max+1;
   }
   /** program main **/
   public static void main(String[] args) {
       SixFourNine sfn = new SixFourNine();
       sfn.runSimulation(1000000);
       try {
           System.out.println(sfn.getWinningNumbers());
       } catch (SixFourNineSimulationNotRunException sfnnre) { // this
cannot happen in this example but we must catch;
           System.out.println("Sorry, there was a problem; you need to
run a simulation before you can guess the winning numbers!");
           System.exit(42);
       }
       System.exit(0);
   }
   public class SixFourNineSimulationNotRunException extends Exception
{};
}

How do you mean "statistically solid"?  Unless you know of some flaw in  
the machine that picks the numbers, any set of six numbers is equally  
likely to come up as any other.  You may as well pick 1, 2, 3, 4, 5 and 6  
and be done with it.  Unless, as Stefan suggested, you want to maximise  
your winnings if you ever hit the jackpot, in which case you need data  
about how often each number is selected by other players.  In the absence  
of any hard data, I would guess that picking high numbers is the way to go  
as many people pick numbers that correspond to dates (birthdays,  
anniversaries etc.), which are all in the range 1-31.

java.util.Random is not very good at generating statistically random  
numbers.  See Roedy Green's page  
(http://mindprod.com/jgloss/pseudorandom.html) for more details.  An  
improvement would be to use the SecureRandom class, which has a better  
distribution but is a bit slower.

Dan.