Java Factory.createPermutationGenerator方法代码示例

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
static void permutation_without_repetitions() {

        System.out.println("===== Permutations Without Repetitions: =====");

        // Create the initial set/vector of 3 elements (apple, orange, cherry)
        ICombinatoricsVector<String> originalVector = Factory
                .createVector(new String[]{"apple", "orange", "cherry"});

        // Create the permutation generator by calling the appropriate method in
        // the Factory class
        Generator<String> gen = Factory
                .createPermutationGenerator(originalVector);

        // Print the result
        for (ICombinatoricsVector<String> perm : gen)
            System.out.println(perm);

    }
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
static void simple_with_equal_elements_permutation() {

        System.out.println("===== Simple With Equal Elements Permutations: =====");

        // Create the initial vector
        ICombinatoricsVector<Integer> initialVector = Factory
                .createVector(new Integer[]{1, 1, 2, 2});

        // Create the generator
        Generator<Integer> generator = Factory
                .createPermutationGenerator(initialVector);

        for (ICombinatoricsVector<Integer> perm : generator) {
            System.out.println(perm);
        }
    }
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
/**
 * 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<String> originalVector = Factory.createVector(
            new String[] { "apple", "orange", "cherry", "raspberry" }
    );

    // Create the combination generator by calling the appropriate method in the Factory class
    Generator<String> combinations = Factory.createSimpleCombinationGenerator(originalVector, 3);

    // Print all permutations for all simple 3-combinations
    for (ICombinatoricsVector<String> comb : combinations){
        Generator<String> permutations = Factory.createPermutationGenerator(comb);
        for(ICombinatoricsVector<String> perm : permutations){
            System.out.println(perm);
        }
    }
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void simpleEmptyPermutation() {

	ArrayList<Integer> array = new ArrayList<Integer>();

	ICombinatoricsVector<Integer> corePermutation = Factory
			.createVector(array);
	Generator<Integer> generator = Factory
			.createPermutationGenerator(corePermutation);

	System.out.println("Number of permutations is: "
			+ generator.getNumberOfGeneratedObjects());
	assertEquals(0, generator.getNumberOfGeneratedObjects());

	Iterator<ICombinatoricsVector<Integer>> iterator = generator.iterator();

	while (iterator.hasNext()) {
		iterator.next();
		System.out.println(iterator);
	}

	List<ICombinatoricsVector<Integer>> list = generator
			.generateAllObjects();

	assertEquals(0, list.size());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void allIdenticalPermutation() {

	ICombinatoricsVector<String> initialVector = Factory
			.createVector(new String[] { "a", "a", "a" });
	Generator<String> generator = Factory
			.createPermutationGenerator(initialVector);

	Iterator<ICombinatoricsVector<String>> iterator = generator.iterator();

	while (iterator.hasNext()) {
		iterator.next();
		System.out.println(iterator);
	}

	List<ICombinatoricsVector<String>> list = generator
			.generateAllObjects();

	assertEquals(1, list.size());

	assertEquals("CombinatoricsVector=([a, a, a], size=3)", list.get(0)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
public static ArrayList<List<Character>> permutation(Character[]  elements){
	// Create the initial vector
	ICombinatoricsVector<Character> initialVector = Factory.createVector(elements);
	// Create a simple combination generator to generate 3-combinations of the initial vector
	Generator<Character> gen = Factory.createPermutationGenerator(initialVector);
	// Locate all possible combinations
	ArrayList<List<Character>> permutations = new ArrayList<List<Character>>();
	for (ICombinatoricsVector<Character> combination : gen) {
		permutations.add(combination.getVector());
	}
	return permutations;
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
private List<RelevanceAutomatonWalker> setUpWalkers() {
	SortedSet<Character> alphabetWithoutWildcard = this.vacuAwaWildAuto.getAlphabetWithoutWildcard();
	int k = alphabetWithoutWildcard.size();

	Set<Character> taskIdentifiersInLog = this.logTranslationMap.keySet();
	
	if (taskIdentifiersInLog.size() < k) {
		throw new IllegalArgumentException("Not enough tasks in the log to instanciate the constraint");
	}

	ICombinatoricsVector<Character> initialVector =
			Factory.createVector(taskIdentifiersInLog.toArray(new Character[k+1]));
	Iterator<ICombinatoricsVector<Character>> combosPermIterator = null;
	Generator<Character>
		comboGen = Factory.createSimpleCombinationGenerator(initialVector, k),
		combosPermGen = null;
	ArrayList<RelevanceAutomatonWalker> walkers = new ArrayList<RelevanceAutomatonWalker>();
	List<Character> vectorOfChars = null;
	int i = 0;
	for (ICombinatoricsVector<Character> simpleCombo : comboGen) {
		combosPermGen = Factory.createPermutationGenerator(simpleCombo);
		combosPermIterator = combosPermGen.iterator();
		while (combosPermIterator.hasNext()) {
			vectorOfChars = combosPermIterator.next().getVector();
			walkers.add(i++, new RelevanceAutomatonWalker(
					vectorOfChars,
					alphabetWithoutWildcard,
					logTranslationMap,
					vacuAwaWildAuto.getInitialWildState()));
		}
	}

	return walkers;
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void simplePermutation() {

	ICombinatoricsVector<Integer> corePermutation = Factory
			.createVector(new Integer[] { 1, 2, 3 });
	Generator<Integer> generator = Factory
			.createPermutationGenerator(corePermutation);

	System.out.println("Number of permutations is: "
			+ generator.getNumberOfGeneratedObjects());
	assertEquals(6, generator.getNumberOfGeneratedObjects());

	Iterator<ICombinatoricsVector<Integer>> iterator = generator.iterator();

	while (iterator.hasNext()) {
		iterator.next();
		System.out.println(iterator);
	}

	List<ICombinatoricsVector<Integer>> list = generator
			.generateAllObjects();

	assertEquals(6, list.size());

	assertEquals("CombinatoricsVector=([1, 2, 3], size=3)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([1, 3, 2], size=3)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([3, 1, 2], size=3)", list.get(2)
			.toString());
	assertEquals("CombinatoricsVector=([3, 2, 1], size=3)", list.get(3)
			.toString());
	assertEquals("CombinatoricsVector=([2, 3, 1], size=3)", list.get(4)
			.toString());
	assertEquals("CombinatoricsVector=([2, 1, 3], size=3)", list.get(5)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void simpleOnePermutation() {

	ArrayList<Integer> array = new ArrayList<Integer>();
	array.add(1);

	ICombinatoricsVector<Integer> corePermutation = Factory
			.createVector(array);
	Generator<Integer> generator = Factory
			.createPermutationGenerator(corePermutation);

	System.out.println("Number of permutations is: "
			+ generator.getNumberOfGeneratedObjects());
	assertEquals(1, generator.getNumberOfGeneratedObjects());

	Iterator<ICombinatoricsVector<Integer>> iterator = generator.iterator();

	while (iterator.hasNext()) {
		iterator.next();
		System.out.println(iterator);
	}

	List<ICombinatoricsVector<Integer>> list = generator
			.generateAllObjects();

	assertEquals(1, list.size());

	assertEquals("CombinatoricsVector=([1], size=1)", list.get(0)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void identicalPermutation() {

	ICombinatoricsVector<String> initialVector = Factory
			.createVector(new String[] { "a", "a", "b" });
	Generator<String> generator = Factory
			.createPermutationGenerator(initialVector);

	Iterator<ICombinatoricsVector<String>> iterator = generator.iterator();

	while (iterator.hasNext()) {
		iterator.next();
		System.out.println(iterator);
	}

	List<ICombinatoricsVector<String>> list = generator
			.generateAllObjects();

	assertEquals(3, list.size());

	assertEquals("CombinatoricsVector=([a, a, b], size=3)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([a, b, a], size=3)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([b, a, a], size=3)", list.get(2)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void identicalPermutationTreatAsIdentical() {

	ICombinatoricsVector<String> initialVector = Factory
			.createVector(new String[] { "a", "a", "b" });
	
	Generator<String> generator = Factory
			.createPermutationGenerator(initialVector, true);

	for(ICombinatoricsVector<String> perm : generator)
	{
		System.out.println(perm);
	}

	List<ICombinatoricsVector<String>> list = generator
			.generateAllObjects();

	assertEquals(6, list.size());

	assertEquals("CombinatoricsVector=([a, a, b], size=3)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([a, b, a], size=3)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([b, a, a], size=3)", list.get(2)
			.toString());
	assertEquals("CombinatoricsVector=([b, a, a], size=3)", list.get(3)
			.toString());
	assertEquals("CombinatoricsVector=([a, b, a], size=3)", list.get(4)
			.toString());
	assertEquals("CombinatoricsVector=([a, a, b], size=3)", list.get(5)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void allIdenticalPermutationTreatAsIdentical() {

	ICombinatoricsVector<String> initialVector = Factory
			.createVector(new String[] { "x", "x" ,"x"});
	Generator<String> generator = Factory
			.createPermutationGenerator(initialVector, true);

	Iterator<ICombinatoricsVector<String>> iterator = generator.iterator();

	while (iterator.hasNext()) {
		iterator.next();
		System.out.println(iterator);
	}

	List<ICombinatoricsVector<String>> list = generator
			.generateAllObjects();

	assertEquals(6, list.size());

	assertEquals("CombinatoricsVector=([x, x, x], size=3)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([x, x, x], size=3)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([x, x, x], size=3)", list.get(2)
			.toString());
	assertEquals("CombinatoricsVector=([x, x, x], size=3)", list.get(3)
			.toString());
	assertEquals("CombinatoricsVector=([x, x, x], size=3)", list.get(4)
			.toString());
	assertEquals("CombinatoricsVector=([x, x, x], size=3)", list.get(5)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void abcPermutation() {

	ICombinatoricsVector<String> originalVector = Factory
			.createVector(new String[] { "a", "b", "c" });
	Generator<String> generator = Factory
			.createPermutationGenerator(originalVector);

	System.out.println("Number of permutations is: "
			+ generator.getNumberOfGeneratedObjects());
	assertEquals(6, generator.getNumberOfGeneratedObjects());

	for (ICombinatoricsVector<String> perm : generator) {
		System.out.println(perm);
	}

	List<ICombinatoricsVector<String>> list = generator
			.generateAllObjects();

	assertEquals(6, list.size());

	assertEquals("CombinatoricsVector=([a, b, c], size=3)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([a, c, b], size=3)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([c, a, b], size=3)", list.get(2)
			.toString());
	assertEquals("CombinatoricsVector=([c, b, a], size=3)", list.get(3)
			.toString());
	assertEquals("CombinatoricsVector=([b, c, a], size=3)", list.get(4)
			.toString());
	assertEquals("CombinatoricsVector=([b, a, c], size=3)", list.get(5)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void anyExpressionPermutation() {

	ICombinatoricsVector<String> originalVector = Factory
			.createVector(new String[] { "x", "x^2", "x+1" });
	Generator<String> generator = Factory
			.createPermutationGenerator(originalVector);

	System.out.println("Number of permutations is: "
			+ generator.getNumberOfGeneratedObjects());
	assertEquals(6, generator.getNumberOfGeneratedObjects());

	for (ICombinatoricsVector<String> perm : generator) {
		System.out.println(perm);
	}

	List<ICombinatoricsVector<String>> list = generator
			.generateAllObjects();

	assertEquals(6, list.size());

	assertEquals("CombinatoricsVector=([x, x^2, x+1], size=3)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([x, x+1, x^2], size=3)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([x+1, x, x^2], size=3)", list.get(2)
			.toString());
	assertEquals("CombinatoricsVector=([x+1, x^2, x], size=3)", list.get(3)
			.toString());
	assertEquals("CombinatoricsVector=([x^2, x+1, x], size=3)", list.get(4)
			.toString());
	assertEquals("CombinatoricsVector=([x^2, x, x+1], size=3)", list.get(5)
			.toString());
}
 

import org.paukov.combinatorics.Factory; //导入方法依赖的package包/类
@Test
public void simpleWithEqualElementsPermutation() {

	ICombinatoricsVector<Integer> corePermutation = Factory
			.createVector(new Integer[] { 1, 2, 2, 3 });

	Generator<Integer> generator = Factory
			.createPermutationGenerator(corePermutation);

	for (ICombinatoricsVector<Integer> perm : generator) {
		System.out.println(perm);
	}

	List<ICombinatoricsVector<Integer>> list = generator
			.generateAllObjects();

	assertEquals(12, list.size());

	assertEquals("CombinatoricsVector=([1, 2, 2, 3], size=4)", list.get(0)
			.toString());
	assertEquals("CombinatoricsVector=([1, 2, 3, 2], size=4)", list.get(1)
			.toString());
	assertEquals("CombinatoricsVector=([1, 3, 2, 2], size=4)", list.get(2)
			.toString());
	assertEquals("CombinatoricsVector=([2, 1, 2, 3], size=4)", list.get(3)
			.toString());
	assertEquals("CombinatoricsVector=([2, 1, 3, 2], size=4)", list.get(4)
			.toString());
	assertEquals("CombinatoricsVector=([2, 2, 1, 3], size=4)", list.get(5)
			.toString());
	assertEquals("CombinatoricsVector=([2, 2, 3, 1], size=4)", list.get(6)
			.toString());
	assertEquals("CombinatoricsVector=([2, 3, 1, 2], size=4)", list.get(7)
			.toString());
	assertEquals("CombinatoricsVector=([2, 3, 2, 1], size=4)", list.get(8)
			.toString());
	assertEquals("CombinatoricsVector=([3, 1, 2, 2], size=4)", list.get(9)
			.toString());
	assertEquals("CombinatoricsVector=([3, 2, 1, 2], size=4)", list.get(10)
			.toString());
	assertEquals("CombinatoricsVector=([3, 2, 2, 1], size=4)", list.get(11)
			.toString());
}