org.paukov.examples.Main Maven / Gradle / Ivy
The newest version!
/**
* Combinatorics Library
* Copyright 2012 Dmytro Paukov d.paukov@gmail.com
*/
package org.paukov.examples;
import static org.paukov.combinatorics.CombinatoricsFactory.createCartesianProductGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createCompositionGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createMultiCombinationGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createPartitionGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createPermutationGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createPermutationWithRepetitionGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createSimpleCombinationGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createSubSetGenerator;
import static org.paukov.combinatorics.CombinatoricsFactory.createVector;
import static org.paukov.combinatorics.IntegerFactory.createIntegerCompositionGenerator;
import java.util.List;
import org.paukov.combinatorics.Generator;
import org.paukov.combinatorics.ICombinatoricsVector;
import org.paukov.combinatorics.IFilter;
import org.paukov.combinatorics.IntegerGenerator;
import org.paukov.combinatorics.IntegerVector;
import org.paukov.combinatorics.util.ComplexCombinationGenerator;
/**
* This class contains various examples of using the combinatoricslib.
*
* @author Dmytro Paukov
*/
public class Main {
public static void main(String[] args) {
/**
* Permutations
*/
permutation_without_repetitions();
permutation_with_repetitions();
/**
* Combinations
*/
simple_combinations();
multi_combinations();
/**
* Subsets
*/
simple_subsets();
duplicate_subsets();
/**
* Integer partitions and compositions
*/
integer_partition();
integer_composition();
/**
* Complex combination (List partitions)
*/
complex_combination_indexes_example();
complex_combination_example();
simple_with_equal_elements_permutation();
/**
* Examples of the integer vectors
*/
simple_five_integer_composition_range();
/**
* Filters
*/
filtered_combinations();
/**
* Complex examples
*/
all_permutations_of_all_combination();
cartesian_product();
}
static void simple_combinations() {
System.out.println("===== Simple Combinations: =====");
// Create the initial vector
ICombinatoricsVector initialVector = createVector("red", "black", "white", "green",
"blue");
// Create a simple combination generator to generate 3-combinations of
// the initial vector
Generator gen = createSimpleCombinationGenerator(initialVector, 3);
// Print all possible combinations
for (ICombinatoricsVector combination : gen) {
System.out.println(combination);
}
}
static void multi_combinations() {
System.out.println("===== Multi Combinations: =====");
// Create the initial vector of (apple, orange)
ICombinatoricsVector initialVector = createVector("apple", "orange");
// Create a multi-combination generator to generate 3-combinations of
// the initial vector
Generator gen = createMultiCombinationGenerator(initialVector, 3);
// Print all possible combinations
for (ICombinatoricsVector combination : gen) {
System.out.println(combination);
}
}
static void permutation_with_repetitions() {
System.out.println("===== Permutation With Repetitions: =====");
// Create the initial set/vector of 2 elements (apple, orange)
ICombinatoricsVector originalVector = createVector("apple", "orange");
// Create the generator by calling the appropriate method in the Factory
// class
Generator gen = createPermutationWithRepetitionGenerator(originalVector, 3);
// Print the result
for (ICombinatoricsVector perm : gen) {
System.out.println(perm);
}
}
static void permutation_without_repetitions() {
System.out.println("===== Permutations Without Repetitions: =====");
// Create the initial set/vector of 3 elements (apple, orange, cherry)
ICombinatoricsVector originalVector = createVector("apple", "orange", "cherry");
// Create the permutation generator by calling the appropriate method in
// the Factory class
Generator gen = createPermutationGenerator(originalVector);
// Print the result
for (ICombinatoricsVector perm : gen) {
System.out.println(perm);
}
}
static void complex_combination_indexes_example() {
System.out.println("===== Complex Combination Indexes Example (List partitions): =====");
// A list of elements
String[] elements = new String[]{"A", "B", "B", "C"};
// create a combinatorics vector of indexes (1, 1, 3)
ICombinatoricsVector indixesVector = createVector(1, 1, 3);
// Create a complex-combination generator
Generator> complexGenerator = new ComplexCombinationGenerator<>(
indixesVector, 2);
// Iterate the elements
for (ICombinatoricsVector> combination : complexGenerator) {
String str = ComplexCombinationGenerator.convertIndexes2String(
elements, combination);
System.out.println(str);
}
}
static void complex_combination_example() {
System.out.println("complexCombinationExample");
System.out.println("===== Complex Combination Example: =====");
// create a combinatorics vector (A, B, B, C)
ICombinatoricsVector vector = createVector("A", "B", "B", "C");
// Create a complex-combination generator
Generator> gen = new ComplexCombinationGenerator<>(vector, 2);
// Iterate the combinations
for (ICombinatoricsVector> comb : gen) {
System.out.println(ComplexCombinationGenerator.convert2String(comb)
+ " - " + comb);
}
}
static void simple_subsets() {
System.out.println("===== All subsets: =====");
// Create an initial vector/set
ICombinatoricsVector initialSet = createVector("one", "two", "three");
// Create an instance of the subset generator
Generator gen = createSubSetGenerator(initialSet);
// Print the subsets
for (ICombinatoricsVector subSet : gen) {
System.out.println(subSet);
}
}
static void duplicate_subsets() {
System.out.println("===== All subsets with duplicates: =====");
// Create an initial vector/set (a, b, a, c)
ICombinatoricsVector initialSet = createVector("a", "b", "a", "c");
// Create an instance of the subset generator
Generator gen = createSubSetGenerator(initialSet, false);
// Print the subsets
for (ICombinatoricsVector subSet : gen) {
System.out.println(subSet);
}
}
static void integer_partition() {
System.out.println("===== All integer partitions of 5: =====");
// Create an instance of the partition generator to generate all
// possible partitions of 5
Generator gen = createPartitionGenerator(5);
// Print the partitions
for (ICombinatoricsVector p : gen) {
System.out.println(p);
}
}
static void integer_composition() {
System.out.println("===== All integer combinations of 5: =====");
// Create an instance of the integer composition generator to generate
// all possible compositions of 5
Generator gen = createCompositionGenerator(5);
// Print the compositions
for (ICombinatoricsVector p : gen) {
System.out.println(p);
}
}
static void simple_with_equal_elements_permutation() {
System.out.println("===== Simple With Equal Elements Permutations: =====");
// Create the initial vector
ICombinatoricsVector initialVector = createVector(1, 1, 2, 2);
// Create the generator
Generator generator = createPermutationGenerator(initialVector);
for (ICombinatoricsVector perm : generator) {
System.out.println(perm);
}
}
static void simple_five_integer_composition_range() {
System.out.println("===== Simple Five Integer Composition Range: =====");
IntegerGenerator compositionGenerator = createIntegerCompositionGenerator(5);
List list = compositionGenerator.generateObjectsRange(5, 7);
for (IntegerVector vector : list) {
System.out.println(vector);
}
}
/**
* Print all 3-combinations of the set (apple, orange, cherry, melon) which
* contains orange
*/
static void filtered_combinations() {
System.out.println("===== Filtered Combinations: =====");
// Create the initial set/vector of 3 elements (apple, orange, cherry,
// melon)
ICombinatoricsVector originalVector = createVector("apple", "orange", "cherry",
"melon");
// Create the combination generator by calling the appropriate method in
// the Factory class
Generator gen = createSimpleCombinationGenerator(originalVector, 3);
// Create a filter and generate the results
List> result = gen
.generateFilteredObjects(new IFilter>() {
// returns true if the value is accepted
public boolean accepted(long index,
ICombinatoricsVector value) {
return value.contains("orange");
}
});
// Print the result
for (ICombinatoricsVector perm : result) {
System.out.println(perm);
}
}
/**
* This example recreates the issue 14.
* https://code.google.com/p/combinatoricslib/issues/detail?id=14
*
* It generates all permutations of a given length where repetition is NOT allowed,
* from a larger set of elements.
*/
static void all_permutations_of_all_combination() {
System.out.println("===== All permutations of all combination: =====");
// Create the initial vector of 4 elements (apple, orange, cherry, raspberry)
ICombinatoricsVector originalVector = createVector("apple", "orange", "cherry",
"raspberry");
// Create the combination generator by calling the appropriate method in the Factory class
Generator combinations = createSimpleCombinationGenerator(originalVector, 3);
// Print all permutations for all simple 3-combinations
for (ICombinatoricsVector comb : combinations) {
Generator permutations = createPermutationGenerator(comb);
for (ICombinatoricsVector perm : permutations) {
System.out.println(perm);
}
}
}
static void cartesian_product() {
System.out.println("===== Cartesian Product: =====");
ICombinatoricsVector set01 = createVector(1, 2);
ICombinatoricsVector set02 = createVector(4);
ICombinatoricsVector set03 = createVector(5, 6);
Generator generator = createCartesianProductGenerator(set01, set02, set03);
for (ICombinatoricsVector catresianProduct : generator) {
System.out.println(catresianProduct);
}
}
}