dpaukov / combinatoricslib3 Goto Github PK

Original k-permutation example print output into console. while cannot collect result into a collection for further processing.

        Generator.combination("1", "2", "3", "4")
                .simple(2)
                .stream()
                .forEach(combination -> Generator.permutation(combination)
                        .simple()
                        .stream()
                        .forEach(System.out::println))

Below example collect result into a collection for further processing

        List<List<String>> kPermutationResult = Generator.combination("1", "2", "3", "4")
                .simple(2)
                .stream()
                .flatMap(combination -> Generator.permutation(combination)
                        .simple()
                        .stream()
                        )
                .collect(Collectors.toList());

Hi,

Thanks for your excellent work, this is truly handful AND elegant, which is remarkable.
I was wondering if you are going to add k-permutations in your library, would definitely make it 100% awesome.

Regards

Varargs is very convenient when we want to write each parameter at function call.
However, it is quite less convenient when the input parameters we have are in a List because converting List<List<AnyType>> into List<AnyType>[] is not easy in Java.
I think it would be useful to have a cartesian product with in collection input parameter like it is already done for subset, permutation and combination.

Please, implement for all Generators:
Return -array[] or -List() of chunked Streams of precalculated (but not yet generated as output) combinations
according to input parallel thread number as a divisor for total precalculated number of output combinations, i.g.:

   int n = Runtime.getRuntime().availableProcessors();
   assert n == 8;
   Generator.combination("red", "black", "white", "green", "blue")
       .simple(3)
       .asArrayOfStreamsForGivenThreads(n) //returns Stream[] or List<Stream>
       .stream()
       .parallel()
       .forEach(e->e.forEach(System.out::println));

so, therefore user can process in parallel in chunks:

   [red, black, white] // 0-stream 1st output
   [red, black, green] // 0-stream 2nd output
   [red, black, blue] // 2-stream 1st output
   [red, white, green] // 2-stream 2nd output
   [red, white, blue] // 4-stream 1st output
   [red, green, blue] // 4-stream 2nd output
   [black, white, green] // 1-stream 1st output
   [black, white, blue] // 1-stream 2nd output
   [black, green, blue] // 3-stream 1st output
   [white, green, blue] // 3-stream 2nd output 
   
   //total output ==10 //out of 5-capacity array or list

(5 streams - since it is best match for given threads divisor 10/8 == Math.ceil(5/4) == 2 (so total output 10/per 2 = 5 element-array or list) for output number of array.length or list.size() but precalculated number of total output ==10)
Please note:

1. It is important, that array Stream[] or List should not be prefilled by output generated data, just chunks of stream to be used for further parallel processing

2. In Mathmatics, there are some formulas exist for every type of combination (total output number)

Thank you

Hi,

thanks for the great library. I was thinking about using it in a (future) open source project of mine. However, the complete list of dependencies in my code uses some kind of Apache 2.0 compatible license, so I would like to use Apache 2.0 as well. However, this seems to prevent me from using combinatoricslib3 as it is under LGPLv3 and from my understanding using combinatoricslib3 in a new project would require my project to be under LGPL as well. Is there any chance you would think about dual-licensing the library to be compatible with ASF libraries, e.g. LGPLv3 + Apache 2.0?

Regards
Martin

I have n lists all of the same type. I want to loop through all the possible combinations of pulling one item from each of those lists.

Ex.

List 1 = { Red, Blue, Orange }
List 2 = { Brown }
List 3 = { White, Black }

Red Brown White
Red Brown Black
Blue Brown White
Blue Brown Black
Orange Brown White
Orange Brown Black

How can I do that with this library? Thanks

Is there an implementation for subsets containing exactly n elements.?

This can of course be done with the stream() API, but I assume it will be faster, if its already implemented in the subset iterator itself.

In case you provide an implementation, the ordering of subsets should also be adjusted.

Instead of this ordering in your example:

   []
   [one]
   [two]
   [one, two]
   [three]
   [one, three]
   [two, three]
   [one, two, three]

It should be ordered like this IMO:

   []
   [one]
   [two]
   [three]
   [one, two]
   [one, three]
   [two, three]
   [one, two, three]

Please, implement Subsets-(and other - also useful) generator limitation number, i.e.:

BEFORE:

   Generator.subset("one", "two", "three")
        .simple()
        .before(2)//
        .stream()
        .forEach(System.out::println);

   []
   [one]
   [two]
   [three]

AFTER:

   Generator.subset("one", "two", "three")
        .simple()
        .after(1)//
        .stream()
        .forEach(System.out::println);

   [one, two]
   [one, three]
   [two, three]
   [one, two, three]

STRICT or EXACT:

   Generator.subset("one", "two", "three")
        .simple()
        .strict(2)//.exact(2)
        .stream()
        .forEach(System.out::println);

   [one, two]
   [one, three]
   [two, three]

GIVEN:

   Generator.subset("one", "two", "three")
        .simple()
        .given(1, 3)//
        .stream()
        .forEach(System.out::println);

   [one]
   [two]
   [three]
   [one, two, three]

RANGE:

   Generator.subset("one", "two", "three")
        .simple()
        .range(1, 3)//
        .stream()
        .forEach(System.out::println);

   [one]
   [two]
   [one, two]
   [three]
   [one, three]
   [two, three]
   [one, two, three]

Thx

Thanks dpaukov, very good library. I use this library validate my combination/permutation questions, it is easy to use and quick.

One minor issue is I use k-permutation very frequently, while current API is a little verbose

        Generator.combination(1, 2, 3)
            .simple(2)
            .stream()
            .forEach(combination -> Generator.permutation(combination)
                .simple()
                .forEach(System.out::println));

Can you help provide high level API like:

        Generator.permutation(1, 2, 3)
            .simple(2)
            .stream()
            .forEach(System.out::println));

Thanks a lot.

@Test
public void test_zero_permutation_of_empty_with_repetition() {
  List<List<Object>> permutations = Generator.permutation(Collections.emptyList())
      .withRepetitions(0)
      .stream()
      .collect(toList());

  assertThat(permutations).isEmpty();
}

Expected: test should ✓
Actual: java.lang.IndexOutOfBoundsException

java.lang.IndexOutOfBoundsException: Index 0 out of bounds for length 0
	<3 internal lines>
	at java.base/java.util.Objects.checkIndex(Objects.java:359)
	at java.base/java.util.ArrayList.get(ArrayList.java:427)
	at org.paukov.combinatorics3.PermutationWithRepetitionIterator.<init>(PermutationWithRepetitionIterator.java:24)
	at org.paukov.combinatorics3.PermutationWithRepetitionGenerator.iterator(PermutationWithRepetitionGenerator.java:29)
	at org.paukov.combinatorics3.PermutationWithRepetitionGenerator.stream(PermutationWithRepetitionGenerator.java:34)
	at org.paukov.combinatorics3.PermutationsWithRepetitionsTest.test_zero_permutation_of_empty_with_repetition(PermutationsWithRepetitionsTest.java:89)

From your k-Permutations example:

This will print six 2-permutations of (1, 2, 3):

   [1, 2]
   [2, 1]
   [1, 3]
   [3, 1]
   [2, 3]
   [3, 2]

How can I make the "sort ascending by column"?

   [1, 2]
   [1, 3]
   [2, 1]
   [2, 3]
   [3, 1]
   [3, 2]

What is the best way to determine "the rest of the sequence" generated with the subset() method?
For example to get exactly 3 partitions out of 5 elements and filling the second partition again with a "subset of the rest" and filling last partition with the subset of elements not used in the first 2 partitions?

How to improve this snippet?

Generator.subset(1, 1, 2, 2, 3)
        .simple()
        .stream()
        .forEach(System.out::println);

Hello,

i looking for a toolkit for java.util.BitSet Permutations with repetitions.
How / Can I use the lib?

with regards