Section 20.8. Permuting Sequences

20.8. Permuting Sequences

The functions defined in Example 20-23 shuffle sequences in a number of ways:

• permute constructs a list with all valid permutations of any sequence.

• subset constructs a list with all valid permutations of a specific length.

• combo works like subset, but order doesn't matter: permutations of the same items are filtered out.

These results are useful in a variety of algorithms: searches, statistical analysis, and more. For instance, one way to find an optimal ordering for items is to put them in a list, generate all possible permutations, and simply test each one in turn. All three of the functions make use of the generic sequence slicing tricks of the reversal functions in the prior section so that the result list contains sequences of the same type as the one passed in (e.g., when we permute a string, we get back a list of strings).

Example 20-23. PP3E\Dstruct\Classics\permcomb.py

 def permute(list):     if not list:                                        # shuffle any sequence         return [list]                                   # empty sequence     else:         res = []         for i in range(len(list)):             rest = list[:i] + list[i+1:]                # delete current node             for x in permute(rest):                     # permute the others                 res.append(list[i:i+1] + x)             # add node at front         return res def subset(list, size):     if size == 0 or not list:                            # order matters here         return [list[:0]]                                # an empty sequence     else:         result = []         for i in range(len(list)):             pick = list[i:i+1]                           # sequence slice             rest = list[:i] + list[i+1:]                 # keep [:i] part             for x in subset(rest, size-1):                 result.append(pick + x)         return result def combo(list, size):     if size == 0 or not list:                            # order doesn't matter         return [list[:0]]                                # xyz == yzx     else:         result = []         for i in range(0, (len(list) - size) + 1):       # iff enough left             pick = list[i:i+1]             rest = list[i+1:]                            # drop [:i] part             for x in combo(rest, size - 1):                 result.append(pick + x)         return result 

As in the reversal functions, all three of these work on any sequence object that supports len, slicing, and concatenation operations. For instance, we can use permute on instances of some of the stack classes defined at the start of this chapter; we'll get back a list of stack instance objects with shuffled nodes.

Here are our sequence shufflers in action. Permuting a list enables us to find all the ways the items can be arranged. For instance, for a four-item list, there are 24 possible permutations (4 x 3 x 2 x 1). After picking one of the four for the first position, there are only three left to choose from for the second, and so on. Order matters: [1,2,3] is not the same as [1,3,2], so both appear in the result:

 C:\...\PP3E\Dstruct\Classics>python >>> from permcomb import * >>> permute([1,2,3]) [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] >>> permute('abc') ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'] >>> permute('help') ['help', 'hepl', 'hlep', 'hlpe', 'hpel', 'hple', 'ehlp', 'ehpl', 'elhp', 'elph',  'ephl', 'eplh', 'lhep', 'lhpe', 'lehp', 'leph', 'lphe', 'lpeh', 'phel', 'phle',  'pehl', 'pelh', 'plhe', 'pleh'] 

combo results are related to permutations, but a fixed-length constraint is put on the result, and order doesn't matter: abc is the same as acb, so only one is added to the result set:

 >>> combo([1,2,3], 3) [[1, 2, 3]] >>> combo('abc', 3) ['abc'] >>> combo('abc', 2) ['ab', 'ac', 'bc'] >>> combo('abc', 4) [] >>> combo((1, 2, 3, 4), 3) [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)] >>> for i in range(0, 6): print i, combo("help", i) ... 0 [''] 1 ['h', 'e', 'l', 'p'] 2 ['he', 'hl', 'hp', 'el', 'ep', 'lp'] 3 ['hel', 'hep', 'hlp', 'elp'] 4 ['help'] 5 [] 

Finally, subset is just fixed-length permutations; order matters, so the result is larger than for combo. In fact, calling subset with the length of the sequence is identical to permute:

 >>> subset([1,2,3], 3) [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]] >>> subset('abc', 3) ['abc', 'acb', 'bac', 'bca', 'cab', 'cba'] >>> for i in range(0, 6): print i, subset("help", i) ... 0 [''] 1 ['h', 'e', 'l', 'p'] 2 ['he', 'hl', 'hp', 'eh', 'el', 'ep', 'lh', 'le', 'lp', 'ph', 'pe', 'pl'] 3 ['hel', 'hep', 'hle', 'hlp', 'hpe', 'hpl', 'ehl', 'ehp', 'elh', 'elp', 'eph',    'epl', 'lhe', 'lhp', 'leh', 'lep', 'lph', 'lpe', 'phe', 'phl', 'peh', 'pel',    'plh', 'ple'] 4 ['help', 'hepl', 'hlep', 'hlpe', 'hpel', 'hple', 'ehlp', 'ehpl', 'elhp',    'elph', 'ephl', 'eplh', 'lhep', 'lhpe', 'lehp', 'leph', 'lphe', 'lpeh',    'phel', 'phle', 'pehl', 'pelh', 'plhe', 'pleh'] 5 ['help', 'hepl', 'hlep', 'hlpe', 'hpel', 'hple', 'ehlp', 'ehpl', 'elhp',    'elph', 'ephl', 'eplh', 'lhep', 'lhpe', 'lehp', 'leph', 'lphe', 'lpeh',    'phel', 'phle', 'pehl', 'pelh', 'plhe', 'pleh']