如何最好地比较 Java 整数集？

Question

While learning Java I'm using the lottery like many to sharpen my new skills. As an exercise I want to create all 13.9M 6 ball combinations for a given random seed. I've managed to generate the lines OK for a given seed but I'm not currently checking they're unique and I'm therefore getting duplicates.

What I'd like advice on his what approach to take to check each generated line against the previously generated lines? I'm currently using a set to hold the 6 numbers in each line and was wondering if I should be comparing sets or if I should use a list or something else?

All advice appreciated:-)

Answer 1

You could use containsAll() method. There are ways of generating unique combinations rather than comparing everything. Please share some code.

Set<Integer> nums = new HashSet<Integer>(Arrays.asList(new Integer[] {1, 2, 3, 4, 5}));
Set<Integer> nums2 = new HashSet<Integer>(Arrays.asList(new Integer[] {1, 2, 6, 4, 5}));
System.out.println(nums.containsAll(nums2));

Answer 2

With those amounts of numbers, I'd suggest adding each line to a Set (like HashSet). Now, if you have your own class that represents those lines, you're going to have to override the equals and hashcode methods in that class. But once you've done that, after each addition of the line to the Set, you can see if the set has increased in size with Set.size(). If it hasn't, it was a duplicate. This way the algorithm for checking for duplicates is an order of magnitude less compared to any other solution really.

Answer 3

(Reading up a bit on it for a lottery 6 numbers are chosen between 1 and 49 and a number cannot be repeated twice)

If you wish to make sure a combination is unique by making sure it has not been used before you can do something like

Set<Set<Integer>> previousCombinations = new HashSet<Set<Integer>>();
...
Set<Integer> newCombination = new HashSet<Integer>(Arrays.asList(22, 10, 1, 14, 45, 14));
if (!previousCombinations.add(newCombination)) {
    // its a duplicate
} else {
    // its not a duplicate
}

However another solution which does not require checking previously generated combinations which you might fight interesting is as follows:

This will generate random combinations of lottery numbers that are guaranteed to be unique until all possible combinations are exhausted without having to check all previous randomly generated combinations. Note that the lotto numbers are returned sorted in ascending order so to make it more realistic you can shuffle them.

This works by using

1) A custom random number generator that will generate all of the unique numbers of a custom range in a random order if you keep calling the getNextValue() method without repeats until all numbers have been returned (after which it loops)

2) An algorithm that given a number between 0 and a total number of combinations and returns the actual combination that corresponds to that number. For example in our case 0 corresponds to [0, 1, 2, 3, 4, 5] and 13983815 corresponds to [43, 44, 45, 46, 47, 48]

  public static void main(String[] args) throws Throwable {
    for (int i = 0; i < 1000000; i++) {
      System.out.println(Arrays.toString(getRandomLottoNumbers()));
    }
  }

  private static final RandomFunction lottoFunction = new RandomFunction(choose(49,
      6));

  public static int[] getRandomLottoNumbers() {
    int[] combination = mthCombination(lottoFunction.getNextValue(), 49, 6);
    for (int i = 0; i < combination.length; i++) {
        combination[i]++;
    }
  }

  // Based on http://en.wikipedia.org/wiki/Linear_congruential_generator
  public static final class RandomFunction {

    private final long a;

    private final long c;

    private final long m;

    private int curr = 0;

    public RandomFunction(int period) {
      m = period;
      List<Integer> primes = primeFactors(period);
      Set<Integer> uniquePrimes = new HashSet<Integer>(primes);

      long aMinusOne = 1;
      if (primes.size() >= 2 && primes.get(0) == 2 && primes.get(1) == 2) {
        aMinusOne = 2;
      }

      for (Integer prime : uniquePrimes) {
        aMinusOne *= prime;
      }

      // make 'a' random
      int rand = (int) (1 + (1000 * Math.random()));

      a = (aMinusOne * rand) + 1;

      int potentialC = 0;
      while (potentialC <= 1) {
        potentialC = 2 + (int) (period * Math.random());

        for (Integer prime : uniquePrimes) {
          while (potentialC % prime == 0) {
            potentialC /= prime;
          }
        }
      }
      c = potentialC;
      curr = (int) (period * Math.random());
    }

    public int getNextValue() {
      curr = (int) ((a * curr + c) % m);
      return curr;
    }
  }

  // Based on http://www.codeguru.com/cpp/cpp/algorithms/general/article.php/c16255/Linear-Search-based-algorithm-for-Mth-Lexicographic-ordering-of-Mathematical-Permutation-and-Combina.htm
  public static int[] mthCombination(int m, int n, int k) {
    if (k == 0) {
      return new int[0];
    }
    if (k == n) {
      int[] result = new int[k];
      for (int i = result.length - 1; i >= 0; i--) {
        result[i] = --k;
      }
      return result;
    }
    int subChoose = choose(n - 1, k - 1);
    if (m < subChoose) {
      int[] subResult = mthCombination(m, n - 1, k - 1);
      int[] result = new int[subResult.length + 1];
      for (int i = 0; i < subResult.length; i++) {
        result[i + 1] = subResult[i] + 1;
      }
      return result;
    } else {
      int[] result = mthCombination(m - subChoose, n - 1, k);
      for (int i = 0; i < result.length; i++) {
        result[i]++;
      }
      return result;
    }
  }

  public static int choose(int n, int k) {
    if (k < 0 || k > n) {
      return 0;
    }
    if (k > n / 2) {
      k = n - k;
    }

    long denominator = 1;
    long numerator = 1;
    for (int i = 1; i <= k; i++) {
      denominator *= i;
      numerator *= (n + 1 - i);
    }
    return (int) (numerator / denominator);
  }

  public static List<Integer> primeFactors(int number) {
    List<Integer> primeFactors = new ArrayList<Integer>();
    if (number < 1) {    
      return primeFactors;
    }

    while (number % 2 == 0) {
      primeFactors.add(2);
      number /= 2;
    }
    for (int i = 2; i * i <= number; i += 2) {
      while (number % i == 0) {
        primeFactors.add(i);
        number /= i;
      }
    }
    if (number != 1) {
      primeFactors.add(number);
    }

    return primeFactors;
  }

Answer 4

You can simply use the equals method of the Set interface:

Set<Integer> myFirstSetOfIntegers = Set.of(1,3,17);
Set<Integer> mySecondSetOfIntegers = Set.of(1,3,17);
myFirstSetOfIntegers.equals(mySecondSetOfIntegers)

Check the javadoc description of Set.equals. It does exactly what you're looking for:

* Compares the specified object with this set for equality.  Returns
* {@code true} if the specified object is also a set, the two sets
* have the same size, and every member of the specified set is
* contained in this set (or equivalently, every member of this set is
* contained in the specified set).  This definition ensures that the
* equals method works properly across different implementations of the
* set interface.

I'd also suggest to look into other data structures, in case you're dealing with combinatorially complex algorithms. For instance, you could represent each 6 ball combination with a BitSet. The BitSet::equals should be much faster for your use case compared to Set::equals.