is there a way to generate all unique permutations of a list of items

Question

I have a list of five attributes, each attribute has five different values. I want to generate the Cartesian product of them and filter all unique permutations.

Some background:

I need them to be my input values to solve a logic puzzle. Where I check rules against them to find the right solution.

from itertools import product

# input
names = ['Dana', 'Ingo', 'Jessica', 'Sören', 'Valerie']
ages = [26, 27, 30, 33, 35]
tops = ['Blouse', 'Poloshirt', 'Pullover', 'Sweatshirt', 'T-Shirt']
colors = ['blue', 'yellow', 'green', 'red', 'black']
sizes = ['XS', 'S', 'M', 'L', 'XL']

all_attributes = [names, ages, tops, colors, sizes]

# cartesian product (superset)
inputs = list(product(*all_attributes))

# the following code you do that...

Perhaps a simplified example can make it clear.

Data:

[['Dana', 'Ingo'], [26, 27]]

Cartesian Product of Data:

[('Dana', 26), ('Dana', 27), ('Ingo', 26), ('Ingo', 27)]

What I want:

[[('Dana', 26), ('Ingo', 27)],
 [('Dana', 27), ('Ingo', 26)],
 [('Ingo', 26), ('Dana', 27)],
 [('Ingo', 27), ('Dana', 26)]]

What I don't want:

[[('Dana', 26), ('Ingo', 26)], ...

I don't want multiple occurrences of the same value. The place matters, so it should have permutative character and that for a list of lists with five elements. I guess the output size will be enormous and maybe that isn't possible to compute so it would be nice to specify some place values which are fixed. For example, I Want to set 'Dana' as a first Element name.

Output:

[[('Dana', 26), ('Ingo', 27),
 [('Dana', 27), ('Ingo', 26)]]

Maybe you can tell me, out of curiosity, what the specific mathematical names for the concepts are, which I need?

---

The puzzle:

There are five friends (Dana, Ingo, Jessica, Sören, Valerie) waiting in line at the cash register of a shopping center. They are all of different ages (26, 27, 30, 33, 35) and want to buy different tops (Blouse, Poloshirt, Pullover, Sweatshirt, T-Shirt) for themselves. The tops have different colors (blue, yellow, green, red, black) and sizes (XS, S, M, L, XL).

Rules:

1. The top 'Dana' wants to buy is 'XL'. Behind her (but not directly behind) is someone with a 'black' top.
2. 'Jessica' waits directly in front of a person who wants to buy a 'Poloshirt'.
3. The second person in line wants to buy a 'yellow' top.
4. 'T-Shirt' isn't 'red'.
5. 'Sören' wants to buy a 'Sweatshirt'. The person who waits directly in front of him is older than the one behind him.
6. 'Ingo' needs a top in size 'L'.
7. The last person in line is 30 years old.
8. The oldest person is going to buy the top with the smallest size.
9. The person who waits directly behind 'Valerie', wants to buy a 'red' top, which is bigger than size 'S'.
10. The youngest person wants to buy a 'yellow' top.
11. Jessica is going to buy a 'Blouse'.
12. The third person waiting in line wants to buy a top of size 'M'.
13. The 'Poloshirt' is 'red' or 'yellow' or 'green'.

Answer 1

This will do it, but take a very long time. I reduced the list size because your options as requested have 24,883,200,000 permutations:

from itertools import permutations, product

names = ['Dana', 'Ingo']
ages = [26, 27]
tops = ['Hemd', 'Poloshirt']
colors = ['blau', 'gelb']
sizes = ['XS', 'S']

options = []

# Generate the Cartesian product of all permutations of the options.
for name,age,top,color,size in product(*map(permutations,[names,ages,tops,colors,sizes])):
    # Build the option list. zip() transposes the individual lists.
    option = list(zip(name,age,top,color,size))
    options.append(option)
    print(option)

Output:

[('Dana', 26, 'Hemd', 'blau', 'XS'), ('Ingo', 27, 'Poloshirt', 'gelb', 'S')]
[('Dana', 26, 'Hemd', 'blau', 'S'), ('Ingo', 27, 'Poloshirt', 'gelb', 'XS')]
[('Dana', 26, 'Hemd', 'gelb', 'XS'), ('Ingo', 27, 'Poloshirt', 'blau', 'S')]
[('Dana', 26, 'Hemd', 'gelb', 'S'), ('Ingo', 27, 'Poloshirt', 'blau', 'XS')]
[('Dana', 26, 'Poloshirt', 'blau', 'XS'), ('Ingo', 27, 'Hemd', 'gelb', 'S')]
[('Dana', 26, 'Poloshirt', 'blau', 'S'), ('Ingo', 27, 'Hemd', 'gelb', 'XS')]
[('Dana', 26, 'Poloshirt', 'gelb', 'XS'), ('Ingo', 27, 'Hemd', 'blau', 'S')]
[('Dana', 26, 'Poloshirt', 'gelb', 'S'), ('Ingo', 27, 'Hemd', 'blau', 'XS')]
[('Dana', 27, 'Hemd', 'blau', 'XS'), ('Ingo', 26, 'Poloshirt', 'gelb', 'S')]
[('Dana', 27, 'Hemd', 'blau', 'S'), ('Ingo', 26, 'Poloshirt', 'gelb', 'XS')]
[('Dana', 27, 'Hemd', 'gelb', 'XS'), ('Ingo', 26, 'Poloshirt', 'blau', 'S')]
[('Dana', 27, 'Hemd', 'gelb', 'S'), ('Ingo', 26, 'Poloshirt', 'blau', 'XS')]
[('Dana', 27, 'Poloshirt', 'blau', 'XS'), ('Ingo', 26, 'Hemd', 'gelb', 'S')]
[('Dana', 27, 'Poloshirt', 'blau', 'S'), ('Ingo', 26, 'Hemd', 'gelb', 'XS')]
[('Dana', 27, 'Poloshirt', 'gelb', 'XS'), ('Ingo', 26, 'Hemd', 'blau', 'S')]
[('Dana', 27, 'Poloshirt', 'gelb', 'S'), ('Ingo', 26, 'Hemd', 'blau', 'XS')]
[('Ingo', 26, 'Hemd', 'blau', 'XS'), ('Dana', 27, 'Poloshirt', 'gelb', 'S')]
[('Ingo', 26, 'Hemd', 'blau', 'S'), ('Dana', 27, 'Poloshirt', 'gelb', 'XS')]
[('Ingo', 26, 'Hemd', 'gelb', 'XS'), ('Dana', 27, 'Poloshirt', 'blau', 'S')]
[('Ingo', 26, 'Hemd', 'gelb', 'S'), ('Dana', 27, 'Poloshirt', 'blau', 'XS')]
[('Ingo', 26, 'Poloshirt', 'blau', 'XS'), ('Dana', 27, 'Hemd', 'gelb', 'S')]
[('Ingo', 26, 'Poloshirt', 'blau', 'S'), ('Dana', 27, 'Hemd', 'gelb', 'XS')]
[('Ingo', 26, 'Poloshirt', 'gelb', 'XS'), ('Dana', 27, 'Hemd', 'blau', 'S')]
[('Ingo', 26, 'Poloshirt', 'gelb', 'S'), ('Dana', 27, 'Hemd', 'blau', 'XS')]
[('Ingo', 27, 'Hemd', 'blau', 'XS'), ('Dana', 26, 'Poloshirt', 'gelb', 'S')]
[('Ingo', 27, 'Hemd', 'blau', 'S'), ('Dana', 26, 'Poloshirt', 'gelb', 'XS')]
[('Ingo', 27, 'Hemd', 'gelb', 'XS'), ('Dana', 26, 'Poloshirt', 'blau', 'S')]
[('Ingo', 27, 'Hemd', 'gelb', 'S'), ('Dana', 26, 'Poloshirt', 'blau', 'XS')]
[('Ingo', 27, 'Poloshirt', 'blau', 'XS'), ('Dana', 26, 'Hemd', 'gelb', 'S')]
[('Ingo', 27, 'Poloshirt', 'blau', 'S'), ('Dana', 26, 'Hemd', 'gelb', 'XS')]
[('Ingo', 27, 'Poloshirt', 'gelb', 'XS'), ('Dana', 26, 'Hemd', 'blau', 'S')]
[('Ingo', 27, 'Poloshirt', 'gelb', 'S'), ('Dana', 26, 'Hemd', 'blau', 'XS')]

Answer 2

There is a fundamental problem with the approach of using permutations for the type of logic puzzle you have. The issue is not even that there are so many of them that your solver is unlikely to finish in a reasonable amount of time. The issue is that you don't have an automated way of checking the rules against the problem: having all the possibilities in front of you is pointless unless you have a method to verify them.

To address these issues, I have created a project called Puzzle Solvers:

• https://github.com/madphysicist/puzzle-solvers
• https://pypi.org/project/puzzle-solvers/
• https://puzzle-solvers.readthedocs.io/en/latest/

This is a small project that currently contains a single class of interest: puzzle_solvers.elimination.Solver. This class implements most of the operations you need to solve the process-of-elimination type problem presented in your question. All of the logic is documented, and the tutorial is a walkthrough of your exact problem. I will explain the basics here, so you can understand what I did, and perhaps improve it.

Step 1 is to recognize that position in the queue is an attribute just like age, name, etc. That means that the order is not relevant any more.

Step 2 is to recognize that this is a graph problem in disguise. You have 30 nodes: all the possible attributes (six of them) of each of five individuals. The graph starts out almost complete. Only the edges between attributes of a given type are missing, so you start with 375 instead of the complete 435 edges.

The final goal is to have one edge between each class of attribute among five connected components in the graph. The final number of edges is therefore 5 * 15 = 75.

So how do you remove edges? The simple rules like "'T-Shirt' isn't 'red'" are quite straightforward: just remove that edge. Rules like "The last person in the queue is 30 years old." are simple too, and more profitable in terms of edge removal. All edges between ages that aren't 30 and position 5 are removed, as well as all edges between positions that aren't 5 and age 30. I added a couple of half-baked utility wrappers to check greater than and less than conditions and remove edges that represented impossible combinations.

The most important aspect of the solver is the fact that any time an edge is removed, it completely follows through with all of the logical implications of that operation. Imagine that you have "The 'Poloshirt' is 'red' or 'yellow' or 'green'" and that you have reached a point in your puzzle where none of those three colors is linked to say age 30. That means that whoever is wearing the poloshirt can not be 30 years old. In fact 'Poloshirt' can not have any edges with endpoints that are not shared by those three colors. If you recursively follow through with those inferences, you get a complete solution.

I'm sorry for the shameless plug of my package, but in justification, I did write it just to answer this question.