Specific permutations of 32 card deck (in C)

Question

I want to generate all permutations of 32 card deck, I represent cards as numbers 0-7, so I don´t care about color of the card. The game is very simple (divide deck into two gropus, compare two cards, add both cards to group of bigger card). I have already code this part of game, but deck is now generating randomly, and I want to look to all possibilities of cards, and make some statistics about it. How can I code this card generating? I totaly don´t know, how to code it.

Answer 1

Because I was just studying Aaron Williams 2009 paper "Loopless Generation of Multiset Permutations by Prefix Shifts", I'll contribute a version of his algorithm, which precisely solves this problem. I believe it to be faster than the standard C++ next_permutation which is usually cited for this problem, because it doesn't rely on searching the input vector for the pivot point. But more extensive benchmarking would be required to produce a definitive answer; it is quite possible that it ends up moving more data around.

Williams' implementation of the algorithm avoids data movement by storing the permutation in a linked list, which allows the "prefix shift" (rotate a prefix of the vector by one position) to be implemented by just modifying two next pointers. That makes the algorithm loopless.

My version here differs in a couple of ways.

• First, it uses an ordinary array to store the values, which means that the shift does require a loop. On the other hand, it avoids having to implement a linked-list datatype, and many operations are faster on arrays.

• Second, it uses suffix shifts rather than prefix shifts; in effect, it produces the reverse of each permutation (compared with Williams' implementation). I did that because it simplifies the description of the starting condition.

• Finally, it just does one permutation step. One of the great things about Williams' algorithm is that the state of the permutation sequence can be encapsulated in a single index value (as well as the permutation itself, of course). This implementation returns the state to be provided to the next call. (Since the state variable will be 0 at the end, the return value doubles as a termination indicator.)

Here's the code:

/* Do a single permutation of v in reverse coolex order, using
 * a modification of Aaron Williams' loopless shift prefix algorithm.
 * v must have length n. It may have repeated elements; the permutations
 * generated will be unique.
 * For the first call, v must be sorted into non-descending order and the
 * third parameter must be 1. For subsequent calls, the third parameter must
 * be the return value of the previous call. When the return value is 0,
 * all permutations have been generated.
 */
unsigned multipermute_step(int* v, unsigned n, unsigned state) {
  int old_end = v[n - 1];
  unsigned pivot = state < 2 || v[state - 2] > v[state] ? state - 1 : state - 2;
  int new_end = v[pivot];
  for (; pivot < n - 1; ++pivot) v[pivot] = v[pivot + 1];
  v[pivot] = new_end;
  return new_end < old_end ? n - 1 : state - 1;
}

In case that comment was unclear, you could use the following to produce all shuffles of a deck of 4*k cards without regard to suit:

unsigned n = 4 * k;
int v[n];
for (unsigned i = 0; i < k; ++i)
  for (unsigned j = 0; j < 4; ++j)
    v[4 * i + j] = i;

unsigned state = 1;
do {
  /* process the permutation */ 
} while ((state = multipermute_step(v, n, state);

Actually trying to do that for k == 8 will take a while, since there are 32!/(4!)⁸ possible shuffles. That's about 2.39*10²⁴. But I did do all the shuffles of decks of 16 cards in 0.3 seconds, and I estimate that I could have done 20 cards in half an hour.