The Fisher-Yates shuffle

We want to implement a shuffle.

A shuffle takes a sequence and rearranges the items in it randomly in place; each possibly arrangement has equal probability, i.e., the distribution of possible permutations is uniform.

We’ll implement the Fisher-Yates shuffle, as modernized by Don Knuth and Richard Durstenfeld. Here’s the pseudocode from Wikipedia:

-- To shuffle an array a of n elements (indices 0..n-1):
for i from n−1 downto 1 do
    j ← random integer such that 0 ≤ j ≤ i
    exchange a[j] and a[i]

Pseudocode is almost code, but it’s a little less formal—a little less interested in the details of how things work. No programming language has exactly the syntax above, but it clearly communicates the idea to a human. It’s also common to write prose-based instructions. Here’s the same idea.

To shuffle a sequence of n elements (0-based indexing):

1. For each index i from the last (index n-1) element to the second (index 1):

   1. Let j be a number between 0 and i, inclusive

   2. Swap element i and element j.

So the last element (index n-1) could swap with any element in the list—including itself! Then the second-to-last element (index n-2) could swap with anything but the already-swapped last element. The third-to-last (index n-3) could swap with anything but those last two elements. When we get down to the second element (index 1), it could swap with index 0 or itself. Our loop never touches index 0 directly in i—only (possibly) in j.

Here’s an implementation in Python. What can you do to convince yourself that it’s correct?