Question

I am having a hard time formulating my question so I’ll just show by example.

x = ['abc', 'c', 'w', 't', '3']
a, b = random_split(x, 3)      # first list should be length 3
# e.g. a => ['abc', 'w', 't']
# e.g. b => ['c', '3']

Is there an easy way of splitting a list into two random samples while maintaining the original ordering?

---

Edit: I know that I could use random.sample and then reorder, but I was hoping for an easy, simple, one line method.

Edit 2: Here’s another solution, see if you can improve it:

def random_split(l, a_size):
    a, b = [], []
    m = len(l)
    which = ([a] * a_size) + ([b] * (m - a_size)) 
    random.shuffle(which)

    for array, sample in zip(which, l):
        array.append(sample)

    return a, b

Edit 3: My concern in avoiding sorting was that in the best case scenario it is O(N*log(N)). It should be possible to get a function that scales O(N) Unfortunately, none of the solutions posted so far actually achieve O(N) Though, after a little thought I found one that works and is comparable to @PedroWerneck’s answer in performance. Though, I’m not 100% sure that is truly random.

def random_split(items, size):
  n = len(items)
  a, b = [], []
  for item in items:
    if size > 0 and random.random() < float(size)/n:
      b.append(item)
      size -= 1
    else:
      a.append(item)

    n -= 1

  return a, b

Answer 1

I believe it’s impossible to do the limiting and no sorting after splitting while keeping the randomness in a simpler way than just sampling and reordering.

If there was no limit, it would be as random as the RNG can by by iterating over the list, and choosing randomly which destination list to send the values to:

>>> import random
>>> x = range(20)
>>> a = []
>>> b = []
>>> for v in x:
...     random.choice((a, b)).append(v)
... 
>>> a
[0, 2, 3, 4, 6, 7, 10, 12, 15, 17]
>>> b
[1, 5, 8, 9, 11, 13, 14, 16, 18, 19]

If you can deal with some bias, you can stop appending to the first list when it reaches the limit and still use the solution above. If you’ll deal with small lists like in your example, it shouldn’t be a big deal to retry it until you get the first list length right.

If you want it to be really random and be able to limit the first list size, then you’ll have to give up and reorder at least one of the lists. The closest to a one liner implementation I can think is something like:

>>> x = range(20)
>>> b = x[:]
>>> a = sorted([b.pop(b.index(random.choice(b))) for n in xrange(limit)])
>>> a
[0, 1, 5, 10, 15, 16, 17]
>>> b
[2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14, 18, 19]

You have to sort a, but b has the order kept.

edit

Now, do you really have to avoid reordering at all costs? Many neat solutions were posted, and your second solution is very nice, but none of them is simpler, easier and shorter than:

def random_split(items, size):
    sample = set(random.sample(items, size))
    return sorted(sample), sorted(set(items) - sample)

Even considering both sorting operations, I think it’s hard to beat that one for simplicity and efficiency. Consider how optimized Python’s Timsort is and how most other methods have to iterate over the n items at least once for each list.

If you really must avoid reordering, I guess this one also works and is very easy and simple, but iterates twice:

def random_split(items, size):
    sample = set(random.sample(items, size))
    a = [x for x in items if x in sample]
    b = [x for x in items if x not in sample]
    return a, b

This is essentially the same as Hexparrot’s solution with the set(sample) suggested by senderle to make comparisons O(1), and removing the redundant index sample and enumerate calls. You don’t need that if you deal only with hashable objects.