itertools

I am trying to generate all possible ways to interleave any two arbitrary strings in Python. For example: If the two strings are 'ab' and 'cd' , the output I wish to get is: ['abcd', 'acbd', 'acdb', 'cabd', 'cadb', 'cdab'] See a is always before b (and c before d ). I am struggling to find a solution to this. I have tried itertools as shown below: import itertools def shuffle(s,t): string = s+t for i in itertools.permutations(string): print(''.join(i)) shuffle('ab','cd') But as expected, this returns all possible permutations disregarding order of a and b (and c and d ). The Idea Let the two

Python's succint syntax through its batteries allows verbose code line to be expressed in readable one liners. Consider the following examples ====================================================| for a in range(3): | for b in range(3): | for c in range(3): | print (a,b,c), | - - - - - - - - - - - - - - - - - -| for e in product(range(3), repeat=3): | print e, | ====================================================| for a in range(3): | for b in range(a , 3): | for c in range(b , 3): | print (a,b,c), | - - - - - - - - - - - - - - - - - -| for e in combinations_with_replacement(range(3), 3):|

We have two lists, A and B: A = ['a','b','c'] B = [1, 2] Is there a pythonic way to build the set of all maps between A and B containing 2^n (here 2^3=8)? That is: [(a,1), (b,1), (c,1)] [(a,1), (b,1), (c,2)] [(a,1), (b,2), (c,1)] [(a,1), (b,2), (c,2)] [(a,2), (b,1), (c,1)] [(a,2), (b,1), (c,2)] [(a,2), (b,2), (c,1)] [(a,2), (b,2), (c,2)] Using itertools.product , it's possible to get all the tuples: import itertools as it P = it.product(A, B) [p for p in P] Which gives: Out[3]: [('a', 1), ('a', 2), ('b', 1), ('b', 2), ('c', 1), ('c', 2)] thefourtheye You can do this with itertools.product and

I am using python 3 and I am trying to find a way to get all the permutations of a list while enforcing some constraints. For instance, I have a list L=[1, 2, 3, 4, 5, 6, 7] I want to find all permutations. However, My constraints are: 1 should always come before 2. 3 should come before 4 which in turn should come before 5. Finally, 6 should come before 7. Of course, I can generate all permutations and ignore those which do not follow these constraints but this wouldn't be efficient I guess. This approach filters permutations using a simple filter. import itertools groups = [(1,2),(3,4,5),(6,7

I went through similar posts on the forum but all of them suggest using itertools.product but I was wondering if it can be solved without using it. I want to print all the combinations of outcomes for N flips of a coin. This can be done if N is known in advance. So the number of nested loops will be just N. But if N has to be determined dynamically ( input() function) then I am stuck in implementing it in code. In plain English it is easy to imagine that the number of for loops is proportional to N, but how do I implement it? Do I have to use lambdas or recursion? Below is as example code for