permutation | Permutation library in Ruby

Have you looked into the recent additions that are included in JDK 17?

https://docs.oracle.com/en/java/javase/17/core/pseudorandom-number-generators.html#GUID-08E418B9-036F-4D11-8E1C-5EB19B23D8A1

There are plenty of algorithms available:

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/random/package-summary.html#algorithms

For shuffling cards you likely don't need something that is cryptographically secure.

Using Collections.shuffle should do the trick if you provide a decent RNG.

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Collections.html#shuffle(java.util.List,java.util.Random)

You can get trials in multiple ways. The sketch you mentioned creates the trails by adding opacity to the background with the "fill( 0, 10 )" function.

If you want to know more about p5 functions you can always look them up here: https://p5js.org/reference/. The fill() page shows that the first argument is the color ( 0 for black ) and the second argument is the opacity ( 10 out of 255 ).

In the sketch you mentioned, in draw(), they wrote:

You could use the function developed here to get all possible matrices of dim 5x4, and then filter by the number of 1s using sum.

We'll use gtools::permutations to calculate the ... permutations of inputs, and then use expand.grid to show all combinations within them.

First, we can do it easily on one order of the inputs with:

To simplify your code and make it more efficient you could:

1- use a python set as the container (checking the presence of an element is much faster)

2- add the final output directly

3- avoid to create a temporary list with the permutations, keep it as a generator

The behaviour of BREAK in your example is not right. I update this post thanks to @Littlefoot, and is due to the fact that you are using a SqlDeveloper, a java tool not intended for this kind of reporting.

I created your table and insert the records in both databases, then running the reports you did.

Demo 12cR2

You can definitely generate a union type of permutations/combinations of string values, recursively concatenated via template literal types. Of course, the number permutations and combinations grows quite rapidly as you increase the number of elements to permute and combine. TypeScript can only handle building unions on the order of tens of thousands of elements, and compiler performance tends to suffer when you get close to this. So this approach will only work for small numbers of elements.

Your CardSize example will be fine because you only have two sizes and four breakpoints:

After noting the various comments and other posts, I've not found a reason not to continue using the isWindows check I currently have in my code, which is simply the first test listed:

Here's an O(N³) algorithm, where N is the total length of each string:

1. For every element S_i in S:
   1. Construct an NFA for the regular expression S_i(S₁|...|S_n)*
   2. Construct an NFA for the regular expression (S₁|...|S_i-1|S_i+1|...|S_n)(S₁|...|S_n)*
   3. Construct an NFA that is the intersection of the NFA in step 1.1 and step 1.2
   4. Find the shortest string accepted by the NFA in step 1.3
2. Return the shortest string among the strings in step 1.4

The above algorithm can be improved to O(N²logN):

1. Construct an NFA for the regular expression (S₁|...|S_n)*
2. Construct cross-product of two copies of the NFA in step 1.
3. For each state in the NFA in step 2, find the shortest string accepted by the NFA from that state.
4. Let 𝒮 = {S}.
5. While 𝒮 is not empty:
   1. Take an element T from 𝒮.
   2. Partition T into P and Q somewhat evenly.
   3. Construct an NFA for the regular expression (P₁|...|P_p)(S₁|...|S_n)*, reusing the NFA in step 1.
   4. Construct an NFA for the regular expression (Q₁|...|Q_q)(S₁|...|S_n)*, reusing the NFA in step 1.
   5. Construct cross-product of the NFA in step 5.3 and step 5.4, reusing the NFA in step 2.
   6. Find the shortest string accepted by the NFA in step 5.5, reusing the result of step 3.
   7. If P has more than 1 element, put P into 𝒮.
   8. If Q has more than 1 element, put Q into 𝒮.
6. Return the shortest string among the strings in step 5.6

Edit: The following is an O(N²) algorithm, improved from the top answer:

1. Let T be every suffix of every string of S.
2. Build a trie out of T.
3. Let G be a weighted directed graph. The vertices are the elements of T, and the edges are: for each string S_i in S and T_j in T, if S_i = T_j + D or T_j = S_i + D (using the trie in step 2 to find all such pairs), add an edge from D to T_j weighted length of S_i.
4. Find the distance from the empty string to every vertex in G.
5. For each string S_i, S_j in S, if S_i != S_j and S_i = S_j + D (using the trie in step 2 to find all such pairs), find the distance from the empty string to D (using step 4).
6. The length of the answer is half of the shortest distance among all distances in step 5. (It's trivial to find the actual answer but I'm too lazy to describe it :p)