Inserting all elements of second list while maintaining the order of the elements in the first list in Python

Question

I have two lists, let's say lst1 = [4, 6, 11, 0, 1, 2, 5] and lst2 = [10, 3, 8]. I would like to list all permutations of inserting lst2 into lst1 such that the order of lst1 is maintained (order of lst2 need not be maintained). All elements in both lists are unique and order matters. Some potential valid results are

[10, 4, 6, 11, 0, 1, 3, 2, 8, 5]

[4, 6, 8, 10, 11, 0, 3, 1, 2, 5]

[4, 8, 6, 10, 11, 0, 1, 3, 2, 5] etc.

(lst1 elements are in order and lst2 elements may not be). Further, lst1 is circular, as is the resultant list containing all elements.

The total number of permutations of 7 (x) and 4(n) elements is given as the rising factorial --> (x+n-1)!/ (x-1)!. In this example, this would equal 7 * 8 * 9 * 10 = 5040 possibilities. error n=3 not 4, so the answer is 504. Thanks to Slothrop for catching the error!!

I tried the following, but it prints results that are not consistent with what I want. It prints lists without some elements of lst2 included in it. (I would like to do other operations for each of these permutations, so the result should not print results without including all elements of lst2.)

for locations in itertools.permutations(range(len(lst1) + len(lst2)-1), len(lst2)):
    result = lst1[:]
    for location, element in zip(locations, lst2):
        result.insert(location, element)
        print(result)

I get 504 results (not 5040) when I take into account circularity. For example, taking `[10, 4, 6, 11, 0, 1, 3, 2, 8, 5]` as a member of the result set, `[4, 6, 11, 0, 1, 3, 2, 8, 5, 10]` isn't included as a separate result, because it's the same circular list expressed using a different arbitrary choice of starting point. — slothrop, Jun 23 '23 at 17:06
The calculation of 5040 seems to have come from putting x=7, n=4. But lst2 has **3** elements, not 4. So the expected number is `(x+n-1)!/ (x-1)!` = 9! / 6! = 9 * 8 * 7 = 504. — slothrop, Jun 23 '23 at 17:20
It is indeed 504 for 7 and 3 elements. 7 * 8* 9 =504. Thanks for catching the error — DandiestOwl, Jun 23 '23 at 17:53

slothrop · Answer 1 · 2023-06-23T17:31:29.787

2

One way: for each configuration of "insert a lst2 item" locations, use a defaultdict that, for a location, gives either the relevant lst2 item, or by default the next element of lst1.

import itertools as it
from collections import defaultdict

lst1 = [4, 6, 11, 0, 1, 2, 5]
lst2 = [10, 3, 8]

total_len = len(lst1) + len(lst2)
results = []

for locations in it.permutations(range(1, total_len), len(lst2)):
    # Note, it's range(1, total_len). Because of the circularity of the result,
    # we can stipulate without loss of generality that element 0 of the result
    # is lst1[0], and avoid generating "distinct" results that differ only
    # modulo a rotation. So 0 isn't an eligible index for placing a lst2 item.
    it1 = iter(lst1)
    item_at_position = defaultdict(lambda: next(it1),
                                    zip(locations, lst2))
    perm = [item_at_position[i] for i in range(total_len)]
    results.append(perm)
    print(perm)

print(len(results))

For the given inputs, this gives 504 results (equal to (x+n-1)!/ (x-1)! with x=7, n=3).

For example, [4, 10, 3, 6, 11, 0, 8, 1, 2, 5] appears as a member of the results list, so [10, 3, 6, 11, 0, 8, 1, 2, 5, 4] does not also appear: that's simply a different way of representing the same circular list, by choosing a different arbitrary starting point to write it from.

For lst1 = [4, 6, 11] and lst2 = [10, 3, 8], it gives 60 results.

edited Jun 23 '23 at 17:31

answered Jun 23 '23 at 16:58

slothrop

3,218
1
18
11

1

great answer, thanks i learned something. this is crazy: `item_at_position = defaultdict(lambda: next(it1), zip(locations, lst2))`. This is so much more pythonic than my solution :) – Sebastian Wozny Jun 23 '23 at 17:39
This seems to work in terms of the number of outcomes in the results list, but for some weird reason, the print(len(results)) does not print anything. Let's say instead of two lists, I have a list of lists. Is there a way to modify the code to loop through and insert the second in the first, then insert the third etc? I will attempt this using a while and post my progress. – DandiestOwl Jun 23 '23 at 18:07
The `print(len(results))` is working for me: https://www.ideone.com/DmhCoq – slothrop Jun 23 '23 at 18:11
Regarding the list of lists, I might not have thought about it deeply enough but I *think* it just reduces to an operation on two lists - because each list apart from the first can end up having its elements scrambled in any order. In which case you could just replace `lst2` in this code with `lst2 + lst3 + ... + lstN`. Basically there's one "fixed-order" list, and the N "insertable" lists can be replaced with a single list which is the concatenation of them. – slothrop Jun 23 '23 at 18:15
Thanks slothrop. I was able to print the results as well. I agree with your intuition. I think I need to replace lst1 with the results of the previous iteration, – DandiestOwl Jun 23 '23 at 18:26
That would work, but (unless you need the intermediate results) it should also be possible without multiple iterations. Produce a concatenated list like `lst_2thruN = lst_2 + lst_3 + ... + lst_N`. And then follow the procedure in this code, with `lst1` and `lst_2thruN` as the two input lists: that should give the right final result. – slothrop Jun 23 '23 at 18:35
Right. In my understanding of the problem, that didn't constitute the same cyclic order, i.e. `[0, 1, 2, 3, 4]` is cyclically equivalent to `[1, 2, 3, 4, 0]` (which involves just a rotation) but not to `[4, 3, 2, 1, 0]` (which involves a reflection). If the "reflected" list should be treated as a distinct list, wouldn't the expected result for x=7, n=3 have 1008 items rather than 504? – slothrop Jun 24 '23 at 21:36
You can observe the same behaviour with the original example. If the items of `lst1` can appear in reflected order, then the result for `lst1 = [4, 6, 11, 0, 1, 2, 5]` and `lst2 = [10, 3, 8]` would include (among others) `[4, 5, 10, 2, 3, 1, 8, 0, 11, 6]`. But this isn't in the set of 504 results. – slothrop Jun 24 '23 at 21:40
Thank you for the comment. To clarify, I am looking at a circular list, so as long as the "relative order" is the same (clockwise vs anticlockwise, the calculated tour length should be the same. The issue I was facing is that I was checking for the tour length of all outcomes and displaying the perm giving me min value. This does not match the tour given by another piece of software that guarantees soln. I did write a while loop to call this function, so maybe a mistake was made in my loop calling this function. Will investigate. – DandiestOwl Jun 24 '23 at 22:38
1

Genius answer ! You could use a regular dicitonary instead of defaultdict: `item_at_position = dict(zip(locations, lst2))` and use the `get()` method with a short circuit `or` given that the lst2 positions will always be >=1: `perm = [item_at_position.get(i) or next(it1) for i in range(total_len)]` – Alain T. Jul 02 '23 at 18:03
Thanks! That's a good thought. When I originally wrote the code, 0 was a possible lst2 position since I hadn't implemented the "circular list" requirement. If I'd figured that out at the start, then I might indeed have done it the `...get(i) or next(it1)` way. – slothrop Jul 02 '23 at 18:07

Michael Cao · Answer 2 · 2023-06-23T17:12:02.453

0

First generate all possible combinations of insertion locations. Need combination with replacement since we can repeatedly insert at the same index. Then zip it with all permutations of lst2. Since the combinations are always sorted, we can adjust for the changing result length by keeping track of elements inserted.

import itertools as it

lst1 = [4, 6, 11, 0, 1, 2, 5]
lst2 = [10, 3, 8]

insertion_locations = it.combinations_with_replacement(range(len(lst1) + 1), len(lst2))

l2_perms = list(it.permutations(lst2, len(lst2)))

results = []

for il in insertion_locations:
    for perm in l2_perms:
        result = lst1.copy()
        inserted = 0

        for index, val in zip(il, perm):
            result.insert(index + inserted, val)
            inserted += 1

        results.append(result)
        print(result)

edited Jun 23 '23 at 17:12

answered Jun 23 '23 at 16:13

Michael Cao

2,278
1
1
13

The problem here is that the insertion changes the length of `result`, so not all possible insertion positions are covered. For example, all the resulting lists have `[...2, 5]` as their last items - nothing gets inserted between or after those. – slothrop Jun 23 '23 at 16:33
This does not include the result `[10, 8, 4, 6, 11, 0, 1, 2, 3, 5]` which I believe should be included. – JonSG Jun 23 '23 at 16:38
This is not right, I am afraid. For list size of 3 and 3 (say [4,6,11] and [10,3,8] it produces only 24 outcomes, where the expectation is 60 (3*4*5). I looked at the result list and there was no insertion between 6 and 11. – DandiestOwl Jun 23 '23 at 16:41
I think I fixed it using combination with replacements and adjusting for the changing result, but I got 120 results instead of 60, so I'm still not sure. – Michael Cao Jun 23 '23 at 17:12

JonSG · Answer 3 · 2023-06-23T17:45:25.417

While not winning any races, I believe this code will give you your list.

import itertools

## ------------------------
## per: https://stackoverflow.com/questions/15415237/in-python-efficiently-determine-if-two-lists-are-shifted-copies-of-one-another
## ------------------------
def is_shifted_copy(l1, l2):
    l1l1 = l1 * 2
    n = len(l1)
    return next((i for i in range(n) if l1l1[i:i + n] == l2), None) is not None
## ------------------------

lst1 = ["1","2"]
lst2 = ["a","b"]
lst3 = lst1 + lst2
results = []
for candidate in itertools.permutations(lst3, len(lst3)):
    ## -----------------
    ## reject candidate if not in acceptable order
    ## -----------------
    test_indexes = [candidate.index(i) for i in lst1]
    if test_indexes != sorted(test_indexes):
        continue
    ## -----------------

    ## -----------------
    ## reject candidate if it is a rotation of an existing candidate
    ## -----------------
    if any(is_shifted_copy(candidate, existing) for existing in results):
        continue
    ## -----------------

    results.append(candidate)

for result in results:
    print(result)

This will give you:

('1', '2', 'a', 'b')
('1', '2', 'b', 'a')
('1', 'a', '2', 'b')
('1', 'a', 'b', '2')
('1', 'b', '2', 'a')
('1', 'b', 'a', '2')

With:

lst1 = [4, 6, 11, 0, 1, 2, 5] 
lst2 =  [10, 3, 8]

The length of the result is 504 items.

This does not address the question in a couple of ways. One, the circular nature. For two lists of 3 and 3 elements, it gives 120 results (has 4,6,11,10,3,8 and 10,3,8,4,6,11 as two different options). Two, the total does not match the numerical formulation given by the rising factorial formula presented in the question. — DandiestOwl, Jun 23 '23 at 17:00
With [1,2] and [a,b], the results list contains b,a,1,2 as well as 1,2,b,a which are the same because it is a circular list. So, there is duplication. Instead of 12, the list should contain 6 — DandiestOwl, Jun 23 '23 at 17:10
Please take a look now and let me know if that is working or not. — JonSG, Jun 23 '23 at 17:40
It should be 504 and not 5040. This matches the theoretical expectation. Thanks!! — DandiestOwl, Jun 23 '23 at 18:01

Sebastian Wozny · Answer 4 · 2023-06-23T17:54:09.367

I also only get 504 elements after accounting for duplicates but the below does it efficiently without storing anything:

from itertools import permutations

def generate_binary_numbers(n, k):
    # yields all binary numbers of bit-length n with exactly k bits set to one
    if k == 0:
        yield [0] * n  # Base case: All zeros
    elif k == n:
        yield [1] * n  # Base case: All ones
    else:
        for num in generate_binary_numbers(n - 1, k - 1):
            yield [1] + num
        for num in generate_binary_numbers(n - 1, k):
            yield [0] + num


def insertion_pattern(lst1, lst2):
    for binary_num in generate_binary_numbers(len(lst1 )+ len(lst2)-1  , len(lst2)):
        yield [0] + binary_num # 0 is never a valid insertion place
        
def all_valid_samples(lst1, lst2):
    for pattern in insertion_pattern(lst1, lst2):
        for permutation in permutations(lst2):
            result = []
            j=0
            k=0
            for i in range(len(lst1)+len(lst2)):
                if pattern[i]==1:
                    # Choose from the permutation if it's a 1
                    result.append(permutation[j])       
                    j+=1
                else:
                    # Choose from list 1 if it's a 0
                    result.append(lst1[k])
                    k+=1
            yield tuple(result)

Example usage

lst1 = [4, 6, 11, 0, 1, 2, 5]
lst2 = [10, 3, 8]
print(len(set(all_valid_samples(lst1,lst2))))

Output:

`result.append(lst2[j])` - should that be `result.append(permutation[j])` ? — slothrop, Jun 23 '23 at 17:41
I got 720 before properly accounting for the elimination of shifted results. Once I eliminated "duplicates" I get a result of length 504. Still not the same as the OP was quoting but in line with some other posted calculations. — JonSG, Jun 23 '23 at 17:50

Alain T. · Answer 5 · 2023-07-02T18:45:23.480

Without using libraries, a recursive generator function could progressively insert items of the second list after each element of the first list:

def insertPatterns(L1,L2):
    if not L2:
        yield L1
        return
    for i in range(1,len(L1)+1):
        yield from insertPatterns(L1[:i]+L2[:1]+L1[i:],L2[1:])

output:

lst1 = [4, 6, 11, 0, 1, 2, 5]
lst2 = [10, 3, 8]

sum(1 for _ in insertPatterns(lst1,lst2)) # 504 patterns

print(*insertPatterns(lst1,lst2),sep="\n")

[4, 8, 3, 10, 6, 11, 0, 1, 2, 5]
[4, 3, 8, 10, 6, 11, 0, 1, 2, 5]
[4, 3, 10, 8, 6, 11, 0, 1, 2, 5]
[4, 3, 10, 6, 8, 11, 0, 1, 2, 5]
[4, 3, 10, 6, 11, 8, 0, 1, 2, 5]
[4, 3, 10, 6, 11, 0, 8, 1, 2, 5]
[4, 3, 10, 6, 11, 0, 1, 8, 2, 5]
[4, 3, 10, 6, 11, 0, 1, 2, 8, 5]
[4, 3, 10, 6, 11, 0, 1, 2, 5, 8]
[4, 8, 10, 3, 6, 11, 0, 1, 2, 5]
[4, 10, 8, 3, 6, 11, 0, 1, 2, 5]
[4, 10, 3, 8, 6, 11, 0, 1, 2, 5]
[4, 10, 3, 6, 8, 11, 0, 1, 2, 5]
[4, 10, 3, 6, 11, 8, 0, 1, 2, 5]
[4, 10, 3, 6, 11, 0, 8, 1, 2, 5]
[4, 10, 3, 6, 11, 0, 1, 8, 2, 5]
[4, 10, 3, 6, 11, 0, 1, 2, 8, 5]
[4, 10, 3, 6, 11, 0, 1, 2, 5, 8]
[4, 8, 10, 6, 3, 11, 0, 1, 2, 5]
[4, 10, 8, 6, 3, 11, 0, 1, 2, 5]
[4, 10, 6, 8, 3, 11, 0, 1, 2, 5]
[4, 10, 6, 3, 8, 11, 0, 1, 2, 5]
[4, 10, 6, 3, 11, 8, 0, 1, 2, 5]
[4, 10, 6, 3, 11, 0, 8, 1, 2, 5]
[4, 10, 6, 3, 11, 0, 1, 8, 2, 5]
[4, 10, 6, 3, 11, 0, 1, 2, 8, 5]
[4, 10, 6, 3, 11, 0, 1, 2, 5, 8]
[4, 8, 10, 6, 11, 3, 0, 1, 2, 5]
[4, 10, 8, 6, 11, 3, 0, 1, 2, 5]
[4, 10, 6, 8, 11, 3, 0, 1, 2, 5]
[4, 10, 6, 11, 8, 3, 0, 1, 2, 5]
[4, 10, 6, 11, 3, 8, 0, 1, 2, 5]
[4, 10, 6, 11, 3, 0, 8, 1, 2, 5]
[4, 10, 6, 11, 3, 0, 1, 8, 2, 5]
[4, 10, 6, 11, 3, 0, 1, 2, 8, 5]
[4, 10, 6, 11, 3, 0, 1, 2, 5, 8]
[4, 8, 10, 6, 11, 0, 3, 1, 2, 5]
[4, 10, 8, 6, 11, 0, 3, 1, 2, 5]
[4, 10, 6, 8, 11, 0, 3, 1, 2, 5]
[4, 10, 6, 11, 8, 0, 3, 1, 2, 5]
[4, 10, 6, 11, 0, 8, 3, 1, 2, 5]
[4, 10, 6, 11, 0, 3, 8, 1, 2, 5]
[4, 10, 6, 11, 0, 3, 1, 8, 2, 5]
[4, 10, 6, 11, 0, 3, 1, 2, 8, 5]
[4, 10, 6, 11, 0, 3, 1, 2, 5, 8]
[4, 8, 10, 6, 11, 0, 1, 3, 2, 5]
[4, 10, 8, 6, 11, 0, 1, 3, 2, 5]
[4, 10, 6, 8, 11, 0, 1, 3, 2, 5]
[4, 10, 6, 11, 8, 0, 1, 3, 2, 5]
[4, 10, 6, 11, 0, 8, 1, 3, 2, 5]
[4, 10, 6, 11, 0, 1, 8, 3, 2, 5]
[4, 10, 6, 11, 0, 1, 3, 8, 2, 5]
[4, 10, 6, 11, 0, 1, 3, 2, 8, 5]
[4, 10, 6, 11, 0, 1, 3, 2, 5, 8]
[4, 8, 10, 6, 11, 0, 1, 2, 3, 5]
[4, 10, 8, 6, 11, 0, 1, 2, 3, 5]
[4, 10, 6, 8, 11, 0, 1, 2, 3, 5]
[4, 10, 6, 11, 8, 0, 1, 2, 3, 5]
[4, 10, 6, 11, 0, 8, 1, 2, 3, 5]
[4, 10, 6, 11, 0, 1, 8, 2, 3, 5]
[4, 10, 6, 11, 0, 1, 2, 8, 3, 5]
[4, 10, 6, 11, 0, 1, 2, 3, 8, 5]
[4, 10, 6, 11, 0, 1, 2, 3, 5, 8]
[4, 8, 10, 6, 11, 0, 1, 2, 5, 3]
[4, 10, 8, 6, 11, 0, 1, 2, 5, 3]
[4, 10, 6, 8, 11, 0, 1, 2, 5, 3]
[4, 10, 6, 11, 8, 0, 1, 2, 5, 3]
[4, 10, 6, 11, 0, 8, 1, 2, 5, 3]
[4, 10, 6, 11, 0, 1, 8, 2, 5, 3]
[4, 10, 6, 11, 0, 1, 2, 8, 5, 3]
[4, 10, 6, 11, 0, 1, 2, 5, 8, 3]
[4, 10, 6, 11, 0, 1, 2, 5, 3, 8]
[4, 8, 3, 6, 10, 11, 0, 1, 2, 5]
[4, 3, 8, 6, 10, 11, 0, 1, 2, 5]
[4, 3, 6, 8, 10, 11, 0, 1, 2, 5]
[4, 3, 6, 10, 8, 11, 0, 1, 2, 5]
[4, 3, 6, 10, 11, 8, 0, 1, 2, 5]
[4, 3, 6, 10, 11, 0, 8, 1, 2, 5]
[4, 3, 6, 10, 11, 0, 1, 8, 2, 5]
[4, 3, 6, 10, 11, 0, 1, 2, 8, 5]
[4, 3, 6, 10, 11, 0, 1, 2, 5, 8]
[4, 8, 6, 3, 10, 11, 0, 1, 2, 5]
[4, 6, 8, 3, 10, 11, 0, 1, 2, 5]
[4, 6, 3, 8, 10, 11, 0, 1, 2, 5]
[4, 6, 3, 10, 8, 11, 0, 1, 2, 5]
[4, 6, 3, 10, 11, 8, 0, 1, 2, 5]
[4, 6, 3, 10, 11, 0, 8, 1, 2, 5]
[4, 6, 3, 10, 11, 0, 1, 8, 2, 5]
[4, 6, 3, 10, 11, 0, 1, 2, 8, 5]
[4, 6, 3, 10, 11, 0, 1, 2, 5, 8]
[4, 8, 6, 10, 3, 11, 0, 1, 2, 5]
[4, 6, 8, 10, 3, 11, 0, 1, 2, 5]
[4, 6, 10, 8, 3, 11, 0, 1, 2, 5]
[4, 6, 10, 3, 8, 11, 0, 1, 2, 5]
[4, 6, 10, 3, 11, 8, 0, 1, 2, 5]
[4, 6, 10, 3, 11, 0, 8, 1, 2, 5]
[4, 6, 10, 3, 11, 0, 1, 8, 2, 5]
[4, 6, 10, 3, 11, 0, 1, 2, 8, 5]
[4, 6, 10, 3, 11, 0, 1, 2, 5, 8]
[4, 8, 6, 10, 11, 3, 0, 1, 2, 5]
[4, 6, 8, 10, 11, 3, 0, 1, 2, 5]
[4, 6, 10, 8, 11, 3, 0, 1, 2, 5]
[4, 6, 10, 11, 8, 3, 0, 1, 2, 5]
[4, 6, 10, 11, 3, 8, 0, 1, 2, 5]
[4, 6, 10, 11, 3, 0, 8, 1, 2, 5]
[4, 6, 10, 11, 3, 0, 1, 8, 2, 5]
[4, 6, 10, 11, 3, 0, 1, 2, 8, 5]
[4, 6, 10, 11, 3, 0, 1, 2, 5, 8]
[4, 8, 6, 10, 11, 0, 3, 1, 2, 5]
[4, 6, 8, 10, 11, 0, 3, 1, 2, 5]
[4, 6, 10, 8, 11, 0, 3, 1, 2, 5]
[4, 6, 10, 11, 8, 0, 3, 1, 2, 5]
[4, 6, 10, 11, 0, 8, 3, 1, 2, 5]
[4, 6, 10, 11, 0, 3, 8, 1, 2, 5]
[4, 6, 10, 11, 0, 3, 1, 8, 2, 5]
[4, 6, 10, 11, 0, 3, 1, 2, 8, 5]
[4, 6, 10, 11, 0, 3, 1, 2, 5, 8]
[4, 8, 6, 10, 11, 0, 1, 3, 2, 5]
[4, 6, 8, 10, 11, 0, 1, 3, 2, 5]
[4, 6, 10, 8, 11, 0, 1, 3, 2, 5]
[4, 6, 10, 11, 8, 0, 1, 3, 2, 5]
[4, 6, 10, 11, 0, 8, 1, 3, 2, 5]
[4, 6, 10, 11, 0, 1, 8, 3, 2, 5]
[4, 6, 10, 11, 0, 1, 3, 8, 2, 5]
[4, 6, 10, 11, 0, 1, 3, 2, 8, 5]
[4, 6, 10, 11, 0, 1, 3, 2, 5, 8]
[4, 8, 6, 10, 11, 0, 1, 2, 3, 5]
[4, 6, 8, 10, 11, 0, 1, 2, 3, 5]
[4, 6, 10, 8, 11, 0, 1, 2, 3, 5]
[4, 6, 10, 11, 8, 0, 1, 2, 3, 5]
[4, 6, 10, 11, 0, 8, 1, 2, 3, 5]
[4, 6, 10, 11, 0, 1, 8, 2, 3, 5]
[4, 6, 10, 11, 0, 1, 2, 8, 3, 5]
[4, 6, 10, 11, 0, 1, 2, 3, 8, 5]
[4, 6, 10, 11, 0, 1, 2, 3, 5, 8]
[4, 8, 6, 10, 11, 0, 1, 2, 5, 3]
[4, 6, 8, 10, 11, 0, 1, 2, 5, 3]
[4, 6, 10, 8, 11, 0, 1, 2, 5, 3]
[4, 6, 10, 11, 8, 0, 1, 2, 5, 3]
[4, 6, 10, 11, 0, 8, 1, 2, 5, 3]
[4, 6, 10, 11, 0, 1, 8, 2, 5, 3]
[4, 6, 10, 11, 0, 1, 2, 8, 5, 3]
[4, 6, 10, 11, 0, 1, 2, 5, 8, 3]
[4, 6, 10, 11, 0, 1, 2, 5, 3, 8]
[4, 8, 3, 6, 11, 10, 0, 1, 2, 5]
[4, 3, 8, 6, 11, 10, 0, 1, 2, 5]
[4, 3, 6, 8, 11, 10, 0, 1, 2, 5]
[4, 3, 6, 11, 8, 10, 0, 1, 2, 5]
[4, 3, 6, 11, 10, 8, 0, 1, 2, 5]
[4, 3, 6, 11, 10, 0, 8, 1, 2, 5]
[4, 3, 6, 11, 10, 0, 1, 8, 2, 5]
[4, 3, 6, 11, 10, 0, 1, 2, 8, 5]
[4, 3, 6, 11, 10, 0, 1, 2, 5, 8]
[4, 8, 6, 3, 11, 10, 0, 1, 2, 5]
[4, 6, 8, 3, 11, 10, 0, 1, 2, 5]
[4, 6, 3, 8, 11, 10, 0, 1, 2, 5]
[4, 6, 3, 11, 8, 10, 0, 1, 2, 5]
[4, 6, 3, 11, 10, 8, 0, 1, 2, 5]
[4, 6, 3, 11, 10, 0, 8, 1, 2, 5]
[4, 6, 3, 11, 10, 0, 1, 8, 2, 5]
[4, 6, 3, 11, 10, 0, 1, 2, 8, 5]
[4, 6, 3, 11, 10, 0, 1, 2, 5, 8]
[4, 8, 6, 11, 3, 10, 0, 1, 2, 5]
[4, 6, 8, 11, 3, 10, 0, 1, 2, 5]
[4, 6, 11, 8, 3, 10, 0, 1, 2, 5]
[4, 6, 11, 3, 8, 10, 0, 1, 2, 5]
[4, 6, 11, 3, 10, 8, 0, 1, 2, 5]
[4, 6, 11, 3, 10, 0, 8, 1, 2, 5]
[4, 6, 11, 3, 10, 0, 1, 8, 2, 5]
[4, 6, 11, 3, 10, 0, 1, 2, 8, 5]
[4, 6, 11, 3, 10, 0, 1, 2, 5, 8]
[4, 8, 6, 11, 10, 3, 0, 1, 2, 5]
[4, 6, 8, 11, 10, 3, 0, 1, 2, 5]
[4, 6, 11, 8, 10, 3, 0, 1, 2, 5]
[4, 6, 11, 10, 8, 3, 0, 1, 2, 5]
[4, 6, 11, 10, 3, 8, 0, 1, 2, 5]
[4, 6, 11, 10, 3, 0, 8, 1, 2, 5]
[4, 6, 11, 10, 3, 0, 1, 8, 2, 5]
[4, 6, 11, 10, 3, 0, 1, 2, 8, 5]
[4, 6, 11, 10, 3, 0, 1, 2, 5, 8]
[4, 8, 6, 11, 10, 0, 3, 1, 2, 5]
[4, 6, 8, 11, 10, 0, 3, 1, 2, 5]
[4, 6, 11, 8, 10, 0, 3, 1, 2, 5]
[4, 6, 11, 10, 8, 0, 3, 1, 2, 5]
[4, 6, 11, 10, 0, 8, 3, 1, 2, 5]
[4, 6, 11, 10, 0, 3, 8, 1, 2, 5]
[4, 6, 11, 10, 0, 3, 1, 8, 2, 5]
[4, 6, 11, 10, 0, 3, 1, 2, 8, 5]
[4, 6, 11, 10, 0, 3, 1, 2, 5, 8]
[4, 8, 6, 11, 10, 0, 1, 3, 2, 5]
[4, 6, 8, 11, 10, 0, 1, 3, 2, 5]
[4, 6, 11, 8, 10, 0, 1, 3, 2, 5]
[4, 6, 11, 10, 8, 0, 1, 3, 2, 5]
[4, 6, 11, 10, 0, 8, 1, 3, 2, 5]
[4, 6, 11, 10, 0, 1, 8, 3, 2, 5]
[4, 6, 11, 10, 0, 1, 3, 8, 2, 5]
[4, 6, 11, 10, 0, 1, 3, 2, 8, 5]
[4, 6, 11, 10, 0, 1, 3, 2, 5, 8]
[4, 8, 6, 11, 10, 0, 1, 2, 3, 5]
[4, 6, 8, 11, 10, 0, 1, 2, 3, 5]
[4, 6, 11, 8, 10, 0, 1, 2, 3, 5]
[4, 6, 11, 10, 8, 0, 1, 2, 3, 5]
[4, 6, 11, 10, 0, 8, 1, 2, 3, 5]
[4, 6, 11, 10, 0, 1, 8, 2, 3, 5]
[4, 6, 11, 10, 0, 1, 2, 8, 3, 5]
[4, 6, 11, 10, 0, 1, 2, 3, 8, 5]
[4, 6, 11, 10, 0, 1, 2, 3, 5, 8]
[4, 8, 6, 11, 10, 0, 1, 2, 5, 3]
[4, 6, 8, 11, 10, 0, 1, 2, 5, 3]
[4, 6, 11, 8, 10, 0, 1, 2, 5, 3]
[4, 6, 11, 10, 8, 0, 1, 2, 5, 3]
[4, 6, 11, 10, 0, 8, 1, 2, 5, 3]
[4, 6, 11, 10, 0, 1, 8, 2, 5, 3]
[4, 6, 11, 10, 0, 1, 2, 8, 5, 3]
[4, 6, 11, 10, 0, 1, 2, 5, 8, 3]
[4, 6, 11, 10, 0, 1, 2, 5, 3, 8]
[4, 8, 3, 6, 11, 0, 10, 1, 2, 5]
[4, 3, 8, 6, 11, 0, 10, 1, 2, 5]
[4, 3, 6, 8, 11, 0, 10, 1, 2, 5]
[4, 3, 6, 11, 8, 0, 10, 1, 2, 5]
[4, 3, 6, 11, 0, 8, 10, 1, 2, 5]
[4, 3, 6, 11, 0, 10, 8, 1, 2, 5]
[4, 3, 6, 11, 0, 10, 1, 8, 2, 5]
[4, 3, 6, 11, 0, 10, 1, 2, 8, 5]
[4, 3, 6, 11, 0, 10, 1, 2, 5, 8]
[4, 8, 6, 3, 11, 0, 10, 1, 2, 5]
[4, 6, 8, 3, 11, 0, 10, 1, 2, 5]
[4, 6, 3, 8, 11, 0, 10, 1, 2, 5]
[4, 6, 3, 11, 8, 0, 10, 1, 2, 5]
[4, 6, 3, 11, 0, 8, 10, 1, 2, 5]
[4, 6, 3, 11, 0, 10, 8, 1, 2, 5]
[4, 6, 3, 11, 0, 10, 1, 8, 2, 5]
[4, 6, 3, 11, 0, 10, 1, 2, 8, 5]
[4, 6, 3, 11, 0, 10, 1, 2, 5, 8]
[4, 8, 6, 11, 3, 0, 10, 1, 2, 5]
[4, 6, 8, 11, 3, 0, 10, 1, 2, 5]
[4, 6, 11, 8, 3, 0, 10, 1, 2, 5]
[4, 6, 11, 3, 8, 0, 10, 1, 2, 5]
[4, 6, 11, 3, 0, 8, 10, 1, 2, 5]
[4, 6, 11, 3, 0, 10, 8, 1, 2, 5]
[4, 6, 11, 3, 0, 10, 1, 8, 2, 5]
[4, 6, 11, 3, 0, 10, 1, 2, 8, 5]
[4, 6, 11, 3, 0, 10, 1, 2, 5, 8]
[4, 8, 6, 11, 0, 3, 10, 1, 2, 5]
[4, 6, 8, 11, 0, 3, 10, 1, 2, 5]
[4, 6, 11, 8, 0, 3, 10, 1, 2, 5]
[4, 6, 11, 0, 8, 3, 10, 1, 2, 5]
[4, 6, 11, 0, 3, 8, 10, 1, 2, 5]
[4, 6, 11, 0, 3, 10, 8, 1, 2, 5]
[4, 6, 11, 0, 3, 10, 1, 8, 2, 5]
[4, 6, 11, 0, 3, 10, 1, 2, 8, 5]
[4, 6, 11, 0, 3, 10, 1, 2, 5, 8]
[4, 8, 6, 11, 0, 10, 3, 1, 2, 5]
[4, 6, 8, 11, 0, 10, 3, 1, 2, 5]
[4, 6, 11, 8, 0, 10, 3, 1, 2, 5]
[4, 6, 11, 0, 8, 10, 3, 1, 2, 5]
[4, 6, 11, 0, 10, 8, 3, 1, 2, 5]
[4, 6, 11, 0, 10, 3, 8, 1, 2, 5]
[4, 6, 11, 0, 10, 3, 1, 8, 2, 5]
[4, 6, 11, 0, 10, 3, 1, 2, 8, 5]
[4, 6, 11, 0, 10, 3, 1, 2, 5, 8]
[4, 8, 6, 11, 0, 10, 1, 3, 2, 5]
[4, 6, 8, 11, 0, 10, 1, 3, 2, 5]
[4, 6, 11, 8, 0, 10, 1, 3, 2, 5]
[4, 6, 11, 0, 8, 10, 1, 3, 2, 5]
[4, 6, 11, 0, 10, 8, 1, 3, 2, 5]
[4, 6, 11, 0, 10, 1, 8, 3, 2, 5]
[4, 6, 11, 0, 10, 1, 3, 8, 2, 5]
[4, 6, 11, 0, 10, 1, 3, 2, 8, 5]
[4, 6, 11, 0, 10, 1, 3, 2, 5, 8]
[4, 8, 6, 11, 0, 10, 1, 2, 3, 5]
[4, 6, 8, 11, 0, 10, 1, 2, 3, 5]
[4, 6, 11, 8, 0, 10, 1, 2, 3, 5]
[4, 6, 11, 0, 8, 10, 1, 2, 3, 5]
[4, 6, 11, 0, 10, 8, 1, 2, 3, 5]
[4, 6, 11, 0, 10, 1, 8, 2, 3, 5]
[4, 6, 11, 0, 10, 1, 2, 8, 3, 5]
[4, 6, 11, 0, 10, 1, 2, 3, 8, 5]
[4, 6, 11, 0, 10, 1, 2, 3, 5, 8]
[4, 8, 6, 11, 0, 10, 1, 2, 5, 3]
[4, 6, 8, 11, 0, 10, 1, 2, 5, 3]
[4, 6, 11, 8, 0, 10, 1, 2, 5, 3]
[4, 6, 11, 0, 8, 10, 1, 2, 5, 3]
[4, 6, 11, 0, 10, 8, 1, 2, 5, 3]
[4, 6, 11, 0, 10, 1, 8, 2, 5, 3]
[4, 6, 11, 0, 10, 1, 2, 8, 5, 3]
[4, 6, 11, 0, 10, 1, 2, 5, 8, 3]
[4, 6, 11, 0, 10, 1, 2, 5, 3, 8]
[4, 8, 3, 6, 11, 0, 1, 10, 2, 5]
[4, 3, 8, 6, 11, 0, 1, 10, 2, 5]
[4, 3, 6, 8, 11, 0, 1, 10, 2, 5]
[4, 3, 6, 11, 8, 0, 1, 10, 2, 5]
[4, 3, 6, 11, 0, 8, 1, 10, 2, 5]
[4, 3, 6, 11, 0, 1, 8, 10, 2, 5]
[4, 3, 6, 11, 0, 1, 10, 8, 2, 5]
[4, 3, 6, 11, 0, 1, 10, 2, 8, 5]
[4, 3, 6, 11, 0, 1, 10, 2, 5, 8]
[4, 8, 6, 3, 11, 0, 1, 10, 2, 5]
[4, 6, 8, 3, 11, 0, 1, 10, 2, 5]
[4, 6, 3, 8, 11, 0, 1, 10, 2, 5]
[4, 6, 3, 11, 8, 0, 1, 10, 2, 5]
[4, 6, 3, 11, 0, 8, 1, 10, 2, 5]
[4, 6, 3, 11, 0, 1, 8, 10, 2, 5]
[4, 6, 3, 11, 0, 1, 10, 8, 2, 5]
[4, 6, 3, 11, 0, 1, 10, 2, 8, 5]
[4, 6, 3, 11, 0, 1, 10, 2, 5, 8]
[4, 8, 6, 11, 3, 0, 1, 10, 2, 5]
[4, 6, 8, 11, 3, 0, 1, 10, 2, 5]
[4, 6, 11, 8, 3, 0, 1, 10, 2, 5]
[4, 6, 11, 3, 8, 0, 1, 10, 2, 5]
[4, 6, 11, 3, 0, 8, 1, 10, 2, 5]
[4, 6, 11, 3, 0, 1, 8, 10, 2, 5]
[4, 6, 11, 3, 0, 1, 10, 8, 2, 5]
[4, 6, 11, 3, 0, 1, 10, 2, 8, 5]
[4, 6, 11, 3, 0, 1, 10, 2, 5, 8]
[4, 8, 6, 11, 0, 3, 1, 10, 2, 5]
[4, 6, 8, 11, 0, 3, 1, 10, 2, 5]
[4, 6, 11, 8, 0, 3, 1, 10, 2, 5]
[4, 6, 11, 0, 8, 3, 1, 10, 2, 5]
[4, 6, 11, 0, 3, 8, 1, 10, 2, 5]
[4, 6, 11, 0, 3, 1, 8, 10, 2, 5]
[4, 6, 11, 0, 3, 1, 10, 8, 2, 5]
[4, 6, 11, 0, 3, 1, 10, 2, 8, 5]
[4, 6, 11, 0, 3, 1, 10, 2, 5, 8]
[4, 8, 6, 11, 0, 1, 3, 10, 2, 5]
[4, 6, 8, 11, 0, 1, 3, 10, 2, 5]
[4, 6, 11, 8, 0, 1, 3, 10, 2, 5]
[4, 6, 11, 0, 8, 1, 3, 10, 2, 5]
[4, 6, 11, 0, 1, 8, 3, 10, 2, 5]
[4, 6, 11, 0, 1, 3, 8, 10, 2, 5]
[4, 6, 11, 0, 1, 3, 10, 8, 2, 5]
[4, 6, 11, 0, 1, 3, 10, 2, 8, 5]
[4, 6, 11, 0, 1, 3, 10, 2, 5, 8]
[4, 8, 6, 11, 0, 1, 10, 3, 2, 5]
[4, 6, 8, 11, 0, 1, 10, 3, 2, 5]
[4, 6, 11, 8, 0, 1, 10, 3, 2, 5]
[4, 6, 11, 0, 8, 1, 10, 3, 2, 5]
[4, 6, 11, 0, 1, 8, 10, 3, 2, 5]
[4, 6, 11, 0, 1, 10, 8, 3, 2, 5]
[4, 6, 11, 0, 1, 10, 3, 8, 2, 5]
[4, 6, 11, 0, 1, 10, 3, 2, 8, 5]
[4, 6, 11, 0, 1, 10, 3, 2, 5, 8]
[4, 8, 6, 11, 0, 1, 10, 2, 3, 5]
[4, 6, 8, 11, 0, 1, 10, 2, 3, 5]
[4, 6, 11, 8, 0, 1, 10, 2, 3, 5]
[4, 6, 11, 0, 8, 1, 10, 2, 3, 5]
[4, 6, 11, 0, 1, 8, 10, 2, 3, 5]
[4, 6, 11, 0, 1, 10, 8, 2, 3, 5]
[4, 6, 11, 0, 1, 10, 2, 8, 3, 5]
[4, 6, 11, 0, 1, 10, 2, 3, 8, 5]
[4, 6, 11, 0, 1, 10, 2, 3, 5, 8]
[4, 8, 6, 11, 0, 1, 10, 2, 5, 3]
[4, 6, 8, 11, 0, 1, 10, 2, 5, 3]
[4, 6, 11, 8, 0, 1, 10, 2, 5, 3]
[4, 6, 11, 0, 8, 1, 10, 2, 5, 3]
[4, 6, 11, 0, 1, 8, 10, 2, 5, 3]
[4, 6, 11, 0, 1, 10, 8, 2, 5, 3]
[4, 6, 11, 0, 1, 10, 2, 8, 5, 3]
[4, 6, 11, 0, 1, 10, 2, 5, 8, 3]
[4, 6, 11, 0, 1, 10, 2, 5, 3, 8]
[4, 8, 3, 6, 11, 0, 1, 2, 10, 5]
[4, 3, 8, 6, 11, 0, 1, 2, 10, 5]
[4, 3, 6, 8, 11, 0, 1, 2, 10, 5]
[4, 3, 6, 11, 8, 0, 1, 2, 10, 5]
[4, 3, 6, 11, 0, 8, 1, 2, 10, 5]
[4, 3, 6, 11, 0, 1, 8, 2, 10, 5]
[4, 3, 6, 11, 0, 1, 2, 8, 10, 5]
[4, 3, 6, 11, 0, 1, 2, 10, 8, 5]
[4, 3, 6, 11, 0, 1, 2, 10, 5, 8]
[4, 8, 6, 3, 11, 0, 1, 2, 10, 5]
[4, 6, 8, 3, 11, 0, 1, 2, 10, 5]
[4, 6, 3, 8, 11, 0, 1, 2, 10, 5]
[4, 6, 3, 11, 8, 0, 1, 2, 10, 5]
[4, 6, 3, 11, 0, 8, 1, 2, 10, 5]
[4, 6, 3, 11, 0, 1, 8, 2, 10, 5]
[4, 6, 3, 11, 0, 1, 2, 8, 10, 5]
[4, 6, 3, 11, 0, 1, 2, 10, 8, 5]
[4, 6, 3, 11, 0, 1, 2, 10, 5, 8]
[4, 8, 6, 11, 3, 0, 1, 2, 10, 5]
[4, 6, 8, 11, 3, 0, 1, 2, 10, 5]
[4, 6, 11, 8, 3, 0, 1, 2, 10, 5]
[4, 6, 11, 3, 8, 0, 1, 2, 10, 5]
[4, 6, 11, 3, 0, 8, 1, 2, 10, 5]
[4, 6, 11, 3, 0, 1, 8, 2, 10, 5]
[4, 6, 11, 3, 0, 1, 2, 8, 10, 5]
[4, 6, 11, 3, 0, 1, 2, 10, 8, 5]
[4, 6, 11, 3, 0, 1, 2, 10, 5, 8]
[4, 8, 6, 11, 0, 3, 1, 2, 10, 5]
[4, 6, 8, 11, 0, 3, 1, 2, 10, 5]
[4, 6, 11, 8, 0, 3, 1, 2, 10, 5]
[4, 6, 11, 0, 8, 3, 1, 2, 10, 5]
[4, 6, 11, 0, 3, 8, 1, 2, 10, 5]
[4, 6, 11, 0, 3, 1, 8, 2, 10, 5]
[4, 6, 11, 0, 3, 1, 2, 8, 10, 5]
[4, 6, 11, 0, 3, 1, 2, 10, 8, 5]
[4, 6, 11, 0, 3, 1, 2, 10, 5, 8]
[4, 8, 6, 11, 0, 1, 3, 2, 10, 5]
[4, 6, 8, 11, 0, 1, 3, 2, 10, 5]
[4, 6, 11, 8, 0, 1, 3, 2, 10, 5]
[4, 6, 11, 0, 8, 1, 3, 2, 10, 5]
[4, 6, 11, 0, 1, 8, 3, 2, 10, 5]
[4, 6, 11, 0, 1, 3, 8, 2, 10, 5]
[4, 6, 11, 0, 1, 3, 2, 8, 10, 5]
[4, 6, 11, 0, 1, 3, 2, 10, 8, 5]
[4, 6, 11, 0, 1, 3, 2, 10, 5, 8]
[4, 8, 6, 11, 0, 1, 2, 3, 10, 5]
[4, 6, 8, 11, 0, 1, 2, 3, 10, 5]
[4, 6, 11, 8, 0, 1, 2, 3, 10, 5]
[4, 6, 11, 0, 8, 1, 2, 3, 10, 5]
[4, 6, 11, 0, 1, 8, 2, 3, 10, 5]
[4, 6, 11, 0, 1, 2, 8, 3, 10, 5]
[4, 6, 11, 0, 1, 2, 3, 8, 10, 5]
[4, 6, 11, 0, 1, 2, 3, 10, 8, 5]
[4, 6, 11, 0, 1, 2, 3, 10, 5, 8]
[4, 8, 6, 11, 0, 1, 2, 10, 3, 5]
[4, 6, 8, 11, 0, 1, 2, 10, 3, 5]
[4, 6, 11, 8, 0, 1, 2, 10, 3, 5]
[4, 6, 11, 0, 8, 1, 2, 10, 3, 5]
[4, 6, 11, 0, 1, 8, 2, 10, 3, 5]
[4, 6, 11, 0, 1, 2, 8, 10, 3, 5]
[4, 6, 11, 0, 1, 2, 10, 8, 3, 5]
[4, 6, 11, 0, 1, 2, 10, 3, 8, 5]
[4, 6, 11, 0, 1, 2, 10, 3, 5, 8]
[4, 8, 6, 11, 0, 1, 2, 10, 5, 3]
[4, 6, 8, 11, 0, 1, 2, 10, 5, 3]
[4, 6, 11, 8, 0, 1, 2, 10, 5, 3]
[4, 6, 11, 0, 8, 1, 2, 10, 5, 3]
[4, 6, 11, 0, 1, 8, 2, 10, 5, 3]
[4, 6, 11, 0, 1, 2, 8, 10, 5, 3]
[4, 6, 11, 0, 1, 2, 10, 8, 5, 3]
[4, 6, 11, 0, 1, 2, 10, 5, 8, 3]
[4, 6, 11, 0, 1, 2, 10, 5, 3, 8]
[4, 8, 3, 6, 11, 0, 1, 2, 5, 10]
[4, 3, 8, 6, 11, 0, 1, 2, 5, 10]
[4, 3, 6, 8, 11, 0, 1, 2, 5, 10]
[4, 3, 6, 11, 8, 0, 1, 2, 5, 10]
[4, 3, 6, 11, 0, 8, 1, 2, 5, 10]
[4, 3, 6, 11, 0, 1, 8, 2, 5, 10]
[4, 3, 6, 11, 0, 1, 2, 8, 5, 10]
[4, 3, 6, 11, 0, 1, 2, 5, 8, 10]
[4, 3, 6, 11, 0, 1, 2, 5, 10, 8]
[4, 8, 6, 3, 11, 0, 1, 2, 5, 10]
[4, 6, 8, 3, 11, 0, 1, 2, 5, 10]
[4, 6, 3, 8, 11, 0, 1, 2, 5, 10]
[4, 6, 3, 11, 8, 0, 1, 2, 5, 10]
[4, 6, 3, 11, 0, 8, 1, 2, 5, 10]
[4, 6, 3, 11, 0, 1, 8, 2, 5, 10]
[4, 6, 3, 11, 0, 1, 2, 8, 5, 10]
[4, 6, 3, 11, 0, 1, 2, 5, 8, 10]
[4, 6, 3, 11, 0, 1, 2, 5, 10, 8]
[4, 8, 6, 11, 3, 0, 1, 2, 5, 10]
[4, 6, 8, 11, 3, 0, 1, 2, 5, 10]
[4, 6, 11, 8, 3, 0, 1, 2, 5, 10]
[4, 6, 11, 3, 8, 0, 1, 2, 5, 10]
[4, 6, 11, 3, 0, 8, 1, 2, 5, 10]
[4, 6, 11, 3, 0, 1, 8, 2, 5, 10]
[4, 6, 11, 3, 0, 1, 2, 8, 5, 10]
[4, 6, 11, 3, 0, 1, 2, 5, 8, 10]
[4, 6, 11, 3, 0, 1, 2, 5, 10, 8]
[4, 8, 6, 11, 0, 3, 1, 2, 5, 10]
[4, 6, 8, 11, 0, 3, 1, 2, 5, 10]
[4, 6, 11, 8, 0, 3, 1, 2, 5, 10]
[4, 6, 11, 0, 8, 3, 1, 2, 5, 10]
[4, 6, 11, 0, 3, 8, 1, 2, 5, 10]
[4, 6, 11, 0, 3, 1, 8, 2, 5, 10]
[4, 6, 11, 0, 3, 1, 2, 8, 5, 10]
[4, 6, 11, 0, 3, 1, 2, 5, 8, 10]
[4, 6, 11, 0, 3, 1, 2, 5, 10, 8]
[4, 8, 6, 11, 0, 1, 3, 2, 5, 10]
[4, 6, 8, 11, 0, 1, 3, 2, 5, 10]
[4, 6, 11, 8, 0, 1, 3, 2, 5, 10]
[4, 6, 11, 0, 8, 1, 3, 2, 5, 10]
[4, 6, 11, 0, 1, 8, 3, 2, 5, 10]
[4, 6, 11, 0, 1, 3, 8, 2, 5, 10]
[4, 6, 11, 0, 1, 3, 2, 8, 5, 10]
[4, 6, 11, 0, 1, 3, 2, 5, 8, 10]
[4, 6, 11, 0, 1, 3, 2, 5, 10, 8]
[4, 8, 6, 11, 0, 1, 2, 3, 5, 10]
[4, 6, 8, 11, 0, 1, 2, 3, 5, 10]
[4, 6, 11, 8, 0, 1, 2, 3, 5, 10]
[4, 6, 11, 0, 8, 1, 2, 3, 5, 10]
[4, 6, 11, 0, 1, 8, 2, 3, 5, 10]
[4, 6, 11, 0, 1, 2, 8, 3, 5, 10]
[4, 6, 11, 0, 1, 2, 3, 8, 5, 10]
[4, 6, 11, 0, 1, 2, 3, 5, 8, 10]
[4, 6, 11, 0, 1, 2, 3, 5, 10, 8]
[4, 8, 6, 11, 0, 1, 2, 5, 3, 10]
[4, 6, 8, 11, 0, 1, 2, 5, 3, 10]
[4, 6, 11, 8, 0, 1, 2, 5, 3, 10]
[4, 6, 11, 0, 8, 1, 2, 5, 3, 10]
[4, 6, 11, 0, 1, 8, 2, 5, 3, 10]
[4, 6, 11, 0, 1, 2, 8, 5, 3, 10]
[4, 6, 11, 0, 1, 2, 5, 8, 3, 10]
[4, 6, 11, 0, 1, 2, 5, 3, 8, 10]
[4, 6, 11, 0, 1, 2, 5, 3, 10, 8]
[4, 8, 6, 11, 0, 1, 2, 5, 10, 3]
[4, 6, 8, 11, 0, 1, 2, 5, 10, 3]
[4, 6, 11, 8, 0, 1, 2, 5, 10, 3]
[4, 6, 11, 0, 8, 1, 2, 5, 10, 3]
[4, 6, 11, 0, 1, 8, 2, 5, 10, 3]
[4, 6, 11, 0, 1, 2, 8, 5, 10, 3]
[4, 6, 11, 0, 1, 2, 5, 8, 10, 3]
[4, 6, 11, 0, 1, 2, 5, 10, 8, 3]
[4, 6, 11, 0, 1, 2, 5, 10, 3, 8]

Inserting all elements of second list while maintaining the order of the elements in the first list in Python

5 Answers5

Example usage