Class Combinations

  • All Implemented Interfaces:
    java.lang.Iterable<int[]>

    public class Combinations
    extends java.lang.Object
    implements java.lang.Iterable<int[]>
    Utility to create combinations (n, k) of k elements in a set of n elements.
    Since:
    3.3
    • Field Summary

      Fields 
      Modifier and Type Field Description
      private Combinations.IterationOrder iterationOrder
      Iteration order.
      private int k
      Number of elements in each combination.
      private int n
      Size of the set from which combinations are drawn.
    • Constructor Summary

      Constructors 
      Modifier Constructor Description
        Combinations​(int n, int k)
      Creates an instance whose range is the k-element subsets of {0, ..., n - 1} represented as int[] arrays.
      private Combinations​(int n, int k, Combinations.IterationOrder iterationOrder)
      Creates an instance whose range is the k-element subsets of {0, ..., n - 1} represented as int[] arrays.
    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      java.util.Comparator<int[]> comparator()
      Defines a lexicographic ordering of combinations.
      int getK()
      Gets the number of elements in each combination.
      int getN()
      Gets the size of the set from which combinations are drawn.
      java.util.Iterator<int[]> iterator()
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
      • Methods inherited from interface java.lang.Iterable

        forEach, spliterator
    • Field Detail

      • n

        private final int n
        Size of the set from which combinations are drawn.
      • k

        private final int k
        Number of elements in each combination.
    • Constructor Detail

      • Combinations

        public Combinations​(int n,
                            int k)
        Creates an instance whose range is the k-element subsets of {0, ..., n - 1} represented as int[] arrays.

        The iteration order is lexicographic: the arrays returned by the iterator are sorted in descending order and they are visited in lexicographic order with significance from right to left. For example, new Combinations(4, 2).iterator() returns an iterator that will generate the following sequence of arrays on successive calls to next():
        [0, 1], [0, 2], [1, 2], [0, 3], [1, 3], [2, 3]

        If k == 0 an iterator containing an empty array is returned; if k == n an iterator containing [0, ..., n - 1] is returned.
        Parameters:
        n - Size of the set from which subsets are selected.
        k - Size of the subsets to be enumerated.
        Throws:
        NotPositiveException - if n < 0.
        NumberIsTooLargeException - if k > n.
      • Combinations

        private Combinations​(int n,
                             int k,
                             Combinations.IterationOrder iterationOrder)
        Creates an instance whose range is the k-element subsets of {0, ..., n - 1} represented as int[] arrays.

        If the iterationOrder argument is set to Combinations.IterationOrder.LEXICOGRAPHIC, the arrays returned by the iterator are sorted in descending order and they are visited in lexicographic order with significance from right to left. For example, new Combinations(4, 2).iterator() returns an iterator that will generate the following sequence of arrays on successive calls to next():
        [0, 1], [0, 2], [1, 2], [0, 3], [1, 3], [2, 3]

        If k == 0 an iterator containing an empty array is returned; if k == n an iterator containing [0, ..., n - 1] is returned.
        Parameters:
        n - Size of the set from which subsets are selected.
        k - Size of the subsets to be enumerated.
        iterationOrder - Specifies the iteration order.
        Throws:
        NotPositiveException - if n < 0.
        NumberIsTooLargeException - if k > n.
    • Method Detail

      • getN

        public int getN()
        Gets the size of the set from which combinations are drawn.
        Returns:
        the size of the universe.
      • getK

        public int getK()
        Gets the number of elements in each combination.
        Returns:
        the size of the subsets to be enumerated.
      • iterator

        public java.util.Iterator<int[]> iterator()
        Specified by:
        iterator in interface java.lang.Iterable<int[]>
      • comparator

        public java.util.Comparator<int[]> comparator()
        Defines a lexicographic ordering of combinations. The returned comparator allows to compare any two combinations that can be produced by this instance's iterator. Its compare(int[],int[]) method will throw exceptions if passed combinations that are inconsistent with this instance:
        • DimensionMismatchException if the array lengths are not equal to k,
        • OutOfRangeException if an element of the array is not within the interval [0, n).
        Returns:
        a lexicographic comparator.