Fisher-Yates Shuffle Algorithm Explained: Fair Random Grouping for Developers

Why random shuffling is harder than it looks

If you need to shuffle names for a classroom, workshop, or online meeting, the goal is simple: every possible order should have the same chance. That is what makes a random group generator trustworthy.

A naive approach loops through an array and swaps each item with a random index from anywhere in the array. It looks fair, but it is not. For an array of length n, that method creates n^n possible sequences of random choices. There are only n! possible permutations. Since n^n is not a multiple of n! when n > 2, some permutations become more likely than others.

Another common shortcut is:

const shuffled = [...items].sort(() => Math.random() - 0.5);

That pattern is not a uniform shuffle. The comparator is inconsistent, and the final distribution depends on the sorting implementation. In practice, some items can remain closer to their original positions than expected.

For fair random grouping, pair generation, or student picking, you need an algorithm designed for shuffling. That algorithm is Fisher-Yates.

How Fisher-Yates works

The Fisher-Yates shuffle was described by Ronald Fisher and Frank Yates in 1938. A modern in-place version was popularized by Donald Knuth in The Art of Computer Programming.

The algorithm runs in O(n) time and needs only one temporary variable for swapping. Start at the last index and walk backward to index 1:

1. Set i to the last index of the array.
2. Pick a random integer j where 0 <= j <= i.
3. Swap the item at i with the item at j.
4. Decrease i by 1.
5. Repeat until i reaches 1.

Here is a JavaScript implementation:

function fisherYatesShuffle(items) {
  const arr = [...items];

  for (let i = arr.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [arr[i], arr[j]] = [arr[j], arr[i]];
  }

  return arr;
}

Example with [A, B, C, D, E]:

Start: [A, B, C, D, E]
i=4, j=1 -> swap E and B -> [A, E, C, D, B]
i=3, j=3 -> swap D and D -> [A, E, C, D, B]
i=2, j=0 -> swap C and A -> [C, E, A, D, B]
i=1, j=1 -> swap E and E -> [C, E, A, D, B]
Result: [C, E, A, D, B]

At each step, one more position is fixed at the end of the array. The random index includes the current position, so an item can stay where it is. That is part of what keeps the distribution uniform.

Why the distribution is uniform

At step i, every item still under consideration, from index 0 through i, has a 1/(i+1) chance of landing at index i. Multiply those probabilities across the whole process, and every permutation of the original list has probability 1/n!. That is the mathematical definition of a fair shuffle.

This matters for educational and team tools. If a teacher shuffles a roster every month, or a facilitator mixes departments for breakout groups, small biases can become visible over time. Fisher-Yates avoids those patterns when the random number source is uniform.

Where this fits in random group tools

A random group generator can use Fisher-Yates as its core shuffle. Once the list is randomly ordered, grouping is straightforward:

• Groups: Slice the shuffled list into chunks. A class of 30 students with a group size of 5 becomes 6 groups of 5.
• Pairs: Split the shuffled list into pairs. If the list is odd, the last pair might be a trio or a leftover, depending on the tool settings.
• Student picking: Take the first item from the shuffled list. That is equivalent to drawing a name from a hat.

The same idea applies to a random pair generator, a student picker, and even a group name generator that shuffles word lists to create combinations.

The original article explains how random-group-generator.com applies this in the browser. According to that source, the tool runs the shuffle client-side, so the list does not need to leave the device. You can read the full source article here: Fisher-Yates Shuffle Algorithm Explained.

FAQ

Does Fisher-Yates make every permutation equally likely?
Yes, provided the random number generator used to choose indices is uniform. Modern pseudorandom generators such as Math.random() are sufficient for classroom grouping, pair generation, and student picking.

Why not just use array.sort(() => Math.random() - 0.5)?
Sorting with a random comparator is not designed for shuffling. It does not produce a uniform distribution, and its behavior depends on the sort implementation. Fisher-Yates is built for the job and has a clean probability model.

Can it handle large lists?
Yes. Fisher-Yates is O(n), so runtime grows linearly with the number of items. Shuffling 1,000 names takes a fraction of a second in a browser, and 10,000 names is usually fast on modern devices.

Is pseudorandomness good enough?
For grouping and selection, yes. Pseudorandom generators pass statistical randomness tests and are unpredictable in practical use. They are not intended for cryptographic lotteries, but they are fine for classroom or workshop shuffles.

Try it

Ready to create unbiased random groups for a class, training session, or meeting? Try it free at random-group-generator.com.