Create a random order of (x, y) pairs, without repeating/subsequent x's

Question

Say I have a list of valid X = [1, 2, 3, 4, 5] and a list of valid Y = [1, 2, 3, 4, 5].

I need to generate all combinations of every element in

Answer 1

Interesting restriction! I probably overthought this, solving a more general problem: shuffling an arbitrary list of sequences such that (if possible) no two adjacent sequences share a first item.

from itertools import product
from random import choice, randrange, shuffle

def combine(*sequences):
    return playlist(product(*sequences))

def playlist(sequence):
    r'''Shuffle a set of sequences, avoiding repeated first elements.
    '''#"""#'''
    result = list(sequence)
    length = len(result)
    if length < 2:
        # No rearrangement is possible.
        return result
    def swap(a, b):
        if a != b:
            result[a], result[b] = result[b], result[a]
    swap(0, randrange(length))
    for n in range(1, length):
        previous = result[n-1][0]
        choices = [x for x in range(n, length) if result[x][0] != previous]
        if not choices:
            # Trapped in a corner: Too many of the same item are left.
            # Backtrack as far as necessary to interleave other items.
            minor = 0
            major = length - n
            while n > 0:
                n -= 1
                if result[n][0] == previous:
                    major += 1
                else:
                    minor += 1
                if minor == major - 1:
                    if n == 0 or result[n-1][0] != previous:
                        break
            else:
                # The requirement can't be fulfilled,
                # because there are too many of a single item.
                shuffle(result)
                break

            # Interleave the majority item with the other items.
            major = [item for item in result[n:] if item[0] == previous]
            minor = [item for item in result[n:] if item[0] != previous]
            shuffle(major)
            shuffle(minor)
            result[n] = major.pop(0)
            n += 1
            while n < length:
                result[n] = minor.pop(0)
                n += 1
                result[n] = major.pop(0)
                n += 1
            break
        swap(n, choice(choices))
    return result

This starts out simple, but when it discovers that it can't find an item with a different first element, it figures out how far back it needs to go to interleave that element with something else. Therefore, the main loop traverses the array at most three times (once backwards), but usually just once. Granted, each iteration of the first forward pass checks each remaining item in the array, and the array itself contains every pair, so the overall run time is O((NM)**2).

For your specific problem:

>>> X = Y = [1, 2, 3, 4, 5]
>>> combine(X, Y)
[(3, 5), (1, 1), (4, 4), (1, 2), (3, 4),
 (2, 3), (5, 4), (1, 5), (2, 4), (5, 5),
 (4, 1), (2, 2), (1, 4), (4, 2), (5, 2),
 (2, 1), (3, 3), (2, 5), (3, 2), (1, 3),
 (4, 3), (5, 3), (4, 5), (5, 1), (3, 1)]

By the way, this compares x values by equality, not by position in the X array, which may make a difference if the array can contain duplicates. In fact, duplicate values might trigger the fallback case of shuffling all pairs together if more than half of the X values are the same.