Combinatorics in Scala: How to iterate/enumerate all possibilities to merge multiple sequences/lists (riffle shuffle permutations) - scala

Question

Updated question:
In my original question I did not know how to refer to the following problem. To clarify my question, I added the following illustration from Wikipedia:
It turns out that the problem is also named after this analogy: Riffle shuffle permutations. Based on this terminology my question simply becomes: How can I iterate/enumerate all riffle shuffle permutations in the general case of multiple decks?
Original question:
Let's assume we are given multiple sequences and we want to merge these sequences into one single sequence. The resulting sequence should preserve the order of the original sequences. Think of merging multiple stacks of cards (say Seq[Seq[T]]) into one single stack (Seq[T]) by randomly drawing a card from any (random) stack. All input stacks should be fully merged into the resulting stack. How can I iterate or enumerate all possible compositions of such a resulting sequence?
To clarify: If I have three stacks A, B, C (of say 5 elements each) then I do not only want the six possible arrangements of these stacks like "all of A, all of B, all of C" and "all of A, all of C, all of B" etc. I rather want all possible compositions like "1. of A, 1. of B, 2. of A, 1. of C, 3. of A, 2. of B, ...".
Since I'm a bit under the weather today, my first approach is terribly ugly and also produces duplicates:
def enumerateCompositions[T](stacks: Seq[Seq[T]], prefix: Seq[T]): Seq[Seq[T]] = {
if (stacks.length == 0) return {
Seq(prefix)
}
stacks.zipWithIndex.flatMap{ case (stack, stackInd) =>
if (stack.length > 0) {
val stacksWithHeadRemoved = stacks.indices.map{ i =>
if (i != stackInd) stacks(i) else stacks(i).drop(1)
}
enumerateCompositions(stacksWithHeadRemoved, prefix :+ stack.head)
} else {
val remainingStacks = stacks.indices.filterNot(_ == stackInd).map(i => stacks(i))
enumerateCompositions(remainingStacks, prefix)
}
}
}
Any idea how to make this more elegant and get rid of the duplicates?

Answer 1

Let's call this operation "to riffle". Here is a clean idomatic solution:
def allRiffles[T](stack1: List[T], stack2: List[T]): List[List[T]] =
(stack1, stack2) match {
case (x :: xs, y :: ys) => {
allRiffles(xs, stack2).map(x :: _) ++
allRiffles(stack1, ys).map(y :: _)
}
case _ => List(stack1 ++ stack2) // at least one is empty
}
def allRifflesSeq[T](stacks: Seq[List[T]]): List[List[T]] =
stacks.foldLeft(List(List[T]())) { (z, x) =>
z.flatMap(y => allRiffles(y, x))
}
allRiffles will produce all the possible rifflings of two stacks. allRifflesSeq will take a sequence of stacks and produce all the possible rifflings using a fold. For example, if allRifflesSeq is given stacks A, B, and C, it first produces all possible rifflings of A and B and then riffles C into each of those rifflings.
Note that allRiffles consumes stacks space proportional to the length of the shortest stack and allRifflesSeq consumes stacks space bounded by the length of the longest stack. Also, the returned list could be huge (combinatoric explosion) and consume a lot of heap space. An Iterator based solution is safer, but much less pretty:
def allRiffles[T](stacks: List[List[T]]): Iterator[List[T]] = new Iterator[List[T]] {
type Frame = (List[List[T]], List[List[T]], List[T])
var stack = List[Frame]((Nil, stacks, Nil))
var ready = false
var cachedHasNext: Boolean = _
var cachedNext: List[T] = _
def computeNext: Unit = {
while (stack.nonEmpty) {
val (doneStacks, stacks, prefix) :: stackTail = stack
stack = stackTail
stacks match {
case Nil => {
cachedNext = prefix.reverse
cachedHasNext = true
return
}
case Nil :: rest =>
stack ::= (doneStacks, rest, prefix)
case (xs#(x :: xtail)) :: rest =>
if (rest.nonEmpty)
stack ::= (xs :: doneStacks, rest, prefix)
val newStacks = doneStacks.reverse ++ (if (xtail.isEmpty) rest
else xtail :: rest)
stack ::= (Nil, newStacks, x :: prefix)
}
}
cachedHasNext = false
}
def ensureReady = {
if (!ready) {
computeNext
ready = true
}
}
def next = {
ensureReady
if (cachedHasNext) {
val next = cachedNext
ready = false
next
} else Iterator.empty.next
}
def hasNext = {
ensureReady
cachedHasNext
}
}

Answer 2

I have written this in Java. The code is following.
import java.util.*;
import java.io.*;
public class RiffleShufflePermutation {
protected static ArrayList<String> a1 = null;
protected static ArrayList<String> a2 = null;
protected static ArrayList<ArrayList<String>> a = new <ArrayList<ArrayList<String>>();
private static int getStartingPosition(ArrayList<String> inA, String inS) {
for(String s : inA)
if (s.equals(inS))
return inA.indexOf(s)+1;
return 0;
}
private static void shootRiffle(int previous, int current) {
ArrayList<ArrayList<String>> newAA = new ArrayList<ArrayList<String>>();
ArrayList<String> newA;
int start;
for(ArrayList<String> al : a) {
start = (previous < 0)?0:getStartingPosition(al,a2.get(previous));
for(int i=start; i<=al.size(); i++) {
newA = new ArrayList<String>();
newA.addAll(al);
newA.add(i,a2.get(current));
newAA.add(newA);
}
}
a.clear();
a.addAll(newAA);
}
public static void main(String[] args) {
a1 = new ArrayList(Arrays.asList("a1","a2","a3"));
a2 = new ArrayList(Arrays.asList("b1","b2"));
a.add(a1);
for (int i=0; i<a2.size(); i++)
shootRiffle(i-1,i);
int i = 0;
for (ArrayList<String> s : a)
System.out.println(String.format("%2d",++i)+":"+s);
}
}
Here is the Output:
1:[b1, b2, a1, a2, a3]
2:[b1, a1, b2, a2, a3]
3:[b1, a1, a2, b2, a3]
4:[b1, a1, a2, a3, b2]
5:[a1, b1, b2, a2, a3]
6:[a1, b1, a2, b2, a3]
7:[a1, b1, a2, a3, b2]
8:[a1, a2, b1, b2, a3]
9:[a1, a2, b1, a3, b2]
10:[a1, a2, a3, b1, b2]
Hopefully this is useful.