Styjun

I have a series of lists, call them A, B, C, D, E. Now every list has 5 elements with identical names, say:

A: [ 'Cars_A', 'Planes_A', 'Houses_A', 'Bikes_A' ] 
B: [ 'Cars_B', 'Planes_B', 'Houses_B', 'Bikes_B' ]
etc..

What I want is a list of lists, of the form:

[ ['Cars_A', 'Planes_B'], ['Cars_A', 'Houses_B'], ['Cars_A', 'Bikes_B'], 
 ['Planes_A', 'Cars_B'], ['Planes_A', 'Houses_B'], ['Planes_A', 'Bikes_B'],
 ['Houses_A', 'Cars_B'], ['Houses_A', 'Planes_B'], ['Houses_A', 'Bikes_B'],
 ['Bikes_A', 'Cars_B'], ['Bikes_A', 'Planes_B'], ['Bikes_A', 'Houses_B'] ] 

As can be seen, the rule for this list is:

• An element cannot be grouped with another element from the same set, for example ['Cars_A', 'Planes_A'] is not allowed.


• An element cannot be grouped with a similar element from a different set, for example ['Cars_A', 'Cars_B'] is not allowed.

My attempt right now is to do nested for loops for all 5 lists, but I want to avoid this if possible. Any ideas?

Using itertools.permutations and itertools.product with filter:

import itertools

l = [['_'.join([i,g])for i in ['cars', 'planes', 'houses', 'bikes']] for g in 'ABCDE']
l 
[['cars_A', 'planes_A', 'houses_A', 'bikes_A'],
 ['cars_B', 'planes_B', 'houses_B', 'bikes_B'],
 ['cars_C', 'planes_C', 'houses_C', 'bikes_C'],
 ['cars_D', 'planes_D', 'houses_D', 'bikes_D'],
 ['cars_E', 'planes_E', 'houses_E', 'bikes_E']]

res = []
for sub in itertools.permutations(l, 2):
 res.extend(list(filter(lambda x: (x[0].split('_')[0]!=x[1].split('_')[0]), itertools.product(*sub)))) 
res
[('cars_A', 'planes_B'),
 ('cars_A', 'houses_B'),
 ('cars_A', 'bikes_B'),
 ('planes_A', 'cars_B'),
 ('planes_A', 'houses_B'),
 ('planes_A', 'bikes_B'),
 ('houses_A', 'cars_B'),
 ...
 ('bikes_E', 'cars_D'),
 ('bikes_E', 'planes_D'),
 ('bikes_E', 'houses_D')]

Here is a simple way using itertools.combinations, let's just make all the pairs first and then filter afterwards.

from itertools import combinations

def filter_(tup):
 x, y = tup
 p1 = x.split('_')
 p2 = y.split('_')
 return (p1[0] != p2[0]) and (p1[1] != p2[1])


list(filter(filter_, combinations([*A, *B], 2)))

[('Cars_A', 'Planes_B'),
 ('Cars_A', 'Houses_B'),
 ('Cars_A', 'Bikes_B'),
 ('Planes_A', 'Cars_B'),
 ('Planes_A', 'Houses_B'),
 ('Planes_A', 'Bikes_B'),
 ('Houses_A', 'Cars_B'),
 ('Houses_A', 'Planes_B'),
 ('Houses_A', 'Bikes_B'),
 ('Bikes_A', 'Cars_B'),
 ('Bikes_A', 'Planes_B'),
 ('Bikes_A', 'Houses_B')]


list(filter(filter_, combinations([*A, *B, *C], 2)))

[('Cars_A', 'Planes_B'),
 ('Cars_A', 'Houses_B'),
 ('Cars_A', 'Bikes_B'),
 ('Cars_A', 'Planes_C'),
 ('Cars_A', 'Houses_C'),
 ('Cars_A', 'Bikes_C'),
 ('Planes_A', 'Cars_B'),
 ('Planes_A', 'Houses_B'),
 ('Planes_A', 'Bikes_B'),
 ('Planes_A', 'Cars_C'),
 ('Planes_A', 'Houses_C'),
 ('Planes_A', 'Bikes_C'),
 ('Houses_A', 'Cars_B'),
 ...

here is a way to do it without itertools, but using a fast data stucture from collections module, named deque

from collections import deque
A=[ 'Cars_A', 'Planes_A', 'Houses_A', 'Bikes_A' ] 
B=[ 'Cars_B', 'Planes_B', 'Houses_B', 'Bikes_B' ]

l=[deque(A),deque(B)]
n = 0
for i in l:
 i.rotate(n)
 n += 1
m = zip(*l)
print(list(m))