wag.dk

FIELD NOTES
ENTRY No. 002
STARDATE 2026.300
Data & Code / Simulations — 2026-09-21

Best way to shuffle cards: 9 methods tested over 10,000 simulated trials

The Center Load Shuffle gives the best result per unit of effort — tested on a standard deck and a 60-card Skip-Bo deck.

The finding

The best way to shuffle cards — when you weigh effort against result — is the Center Load Shuffle. The move is straightforward: pull the middle third of the deck out as a packet and place it on top of the remaining two-thirds, then do a normal riffle. At seven shuffles it reaches 86.2% of a fully random deck on the standard 52-card deck. At ten shuffles it reaches 94.0%. That is the highest score of any single-action method at every round count tested.

If you are willing to spend two physical actions per round, Center Load + Strip Combo goes further still — 93.4% at seven rounds and 98.0% at ten rounds on a standard deck, and it tops the Skip-Bo rankings too.


Background

A new deck of cards comes ace-to-king, every suit in order — about as far from random as a deck can get. The classic result is the Bayer-Diaconis riffle shuffle theorem: seven riffle shuffles is the mathematical threshold where a deck goes from fully ordered to statistically indistinguishable from random. Fewer than seven and detectable order remains; more than seven barely helps.

That raised an obvious question: does how you riffle matter, beyond just the count? To find the best way to shuffle cards, I built nine shuffle variants in Python and ran each one 10,000 times against two decks — a standard 52-card deck, and a 60-card Skip-Bo deck (values 1–12, five copies each, since repeated values stress-test the randomness metric differently). Randomness was measured using rising sequences — counting runs of cards still in ascending original order, the same metric the original proof is built on. A fresh deck has 1 rising sequence; a truly random deck averages (n+1)/2.

The nine methods

Standard Riffle

The baseline. Deck split roughly in half (imperfect cut, not exactly 26/26), then interleaved with a randomised number of alternations (10–20) and variable-sized clumps from each side. This mirrors the actual Gilbert-Shannon-Reeds model behind the Bayer-Diaconis proof.

Heart Cut Shuffle

Pull the middle ~half of the deck out as one packet (a real cardistry move called a "heart cut"), join the leftover top and bottom into the other packet, then riffle the two together.

Center Load Shuffle

Pull the middle ~third out and place it on top of the remaining two-thirds, then do a standard riffle on the restacked deck. This is the best-performing single-action method in the test.

Carousel Shuffle

A multi-round rotating scheme: round 1 pulls a third aside and riffles the rest; each following round splits the current shuffled pile in half, sets one half aside (replacing the previous aside pile), and riffles the other half together with that previous aside pile.

Tilt Shuffle

A deliberately uneven split (roughly 2/3 vs 1/3, which side is bigger randomised) instead of a near-half cut, then a standard riffle.

Undercut Shuffle

Cut roughly a third off the bottom and move it to the top before each riffle.

Strip Shuffle

No interleaving at all. The deck is broken into 4–8 packets pulled off the top one at a time, each dropped on top of the last — which reverses packet order but leaves the cards within each packet untouched. Included as a baseline for "what happens if you never interleave."

Strip + Riffle Combo

One riffle followed by one strip shuffle, repeated per round. Note: each "round" is actually two physical shuffles, not one.

Center Load + Strip Combo

Same idea, but a Center Load Shuffle followed by a strip shuffle each round. Again, two physical shuffles per counted round.

Results — standard 52-card deck

Values are percentage of a truly random deck's rising-sequence count. 100% = fully random.

Method                    1      2      3      4      5      6      7      8      9     10
Center Load + Strip    38.1%  56.7%  70.4%  79.8%  86.1%  90.5%  93.4%  95.5%  96.9%  98.0%
Strip + Riffle Combo   35.5%  53.0%  67.0%  76.3%  83.2%  88.0%  91.4%  93.8%  95.5%  96.9%
Center Load Shuffle    28.2%  45.9%  59.2%  68.9%  76.1%  82.0%  86.2%  89.5%  92.0%  94.0%
Heart Cut Shuffle      25.2%  41.8%  54.8%  64.7%  72.6%  78.8%  83.5%  87.2%  90.0%  92.2%
Undercut Shuffle       26.1%  41.4%  53.6%  63.5%  71.0%  77.2%  82.0%  85.8%  88.9%  91.1%
Standard Riffle        24.1%  40.1%  52.9%  62.9%  70.7%  76.9%  81.8%  85.5%  88.5%  91.0%
Tilt Shuffle           23.6%  39.3%  51.7%  61.6%  69.6%  75.7%  80.6%  84.5%  87.7%  90.3%
Carousel Shuffle       24.7%  39.5%  51.4%  61.1%  68.8%  74.9%  80.0%  83.9%  86.9%  89.7%
Strip Shuffle          21.5%  24.4%  34.6%  38.4%  45.9%  49.4%  55.3%  58.7%  63.1%  65.8%
Shuffle randomness vs number of shuffles — standard 52-card deck

Results — Skip-Bo 60-card deck

Method                    1      2      3      4      5      6      7      8      9     10
Center Load + Strip    33.3%  50.3%  63.0%  71.8%  78.1%  82.6%  85.8%  87.9%  89.4%  90.7%
Strip + Riffle Combo   31.0%  47.1%  59.9%  68.7%  75.2%  79.9%  83.5%  86.1%  88.0%  89.5%
Center Load Shuffle    25.0%  41.1%  53.0%  62.1%  68.9%  74.5%  78.6%  81.9%  84.6%  86.5%
Heart Cut Shuffle      22.6%  37.4%  49.2%  58.2%  65.5%  71.2%  75.6%  79.2%  82.2%  84.4%
Undercut Shuffle       23.1%  37.3%  48.8%  57.7%  65.0%  70.8%  75.2%  79.0%  81.8%  84.0%
Standard Riffle        21.6%  36.2%  48.1%  57.3%  64.7%  70.3%  75.0%  78.6%  81.5%  84.0%
Tilt Shuffle           21.1%  35.5%  47.0%  56.2%  63.6%  69.3%  74.0%  77.8%  80.9%  83.3%
Carousel Shuffle       22.1%  35.7%  47.0%  56.1%  63.2%  69.1%  73.8%  77.7%  80.7%  83.2%
Strip Shuffle          18.3%  20.6%  29.4%  32.8%  39.4%  42.6%  47.7%  50.7%  54.7%  57.5%
Shuffle randomness vs number of shuffles — Skip-Bo 60-card deck

What it means

All the single-action riffle-based methods — Standard, Tilt, Undercut, Heart Cut, Carousel, Center Load — cluster within a few percentage points of each other on both decks. This confirms that how you cut the deck before riffling barely matters. What actually drives randomness is the messiness of the interleave itself: irregular clump sizes falling from each hand, not which packet ends up where.

Center Load Shuffle is the best single-action method. The restack takes one extra step before the riffle, and it consistently scores a few points higher than every other single-action method across every round count on both decks. At seven shuffles on a standard deck it sits at 86.2% — about four points ahead of a plain riffle. If you are sitting at a table and want to shuffle well without thinking about it, this is the move.

The combo methods — Center Load + Strip Combo and Strip + Riffle Combo — clearly outperform every single-action method, but that is partly explained by each "round" actually being two physical shuffles, not one. Center Load + Strip Combo reaches 98.0% of fully random on a standard deck by round 10 and tops the Skip-Bo rankings too. If you are willing to spend the time, it is the ceiling.

Strip Shuffle alone is the clear loser on both decks. It never interleaves cards, so it plateaus far below the others and tops out at only 65.8% after ten rounds on a standard deck. It is only useful as a supplement between riffles, not a replacement.

Reproducing this

All nine shuffle scripts are attached below, plus CompareShuffleResults.py, which scans a folder for the resulting *_shuffle_results.json files, prints the comparison tables above, and generates the charts shown in this post. Each script is self-contained — run it, then run the comparison script in the same folder.

The randomness metric used throughout is rising sequences: a count of how many consecutive card pairs are still in ascending original order. A fresh ordered deck scores 1; a fully random deck averages (n+1)/2. The percentage figures in the tables are each method's average rising-sequence count divided by that target.

Files

FileDescriptionSize
CarouselShuffle.py CarouselShuffle.py - A Monte Carlo simulation that tests how effectively the "carousel shuffle" randomizes playing cards or token decks by measuring the decay of rising sequences across multiple rounds. The program outputs detailed metrics comparing observed shuffling effectiveness to theoretical randomness benchmarks. 6.4 KB
CenterLoadShuffle.py CenterLoadShuffle.py - This script simulates a "center load shuffle" card-shuffling technique to measure how many shuffles are needed to randomize a deck by tracking the decay of rising sequences (ascending subsequences). It runs thousands of trials across multiple shuffle counts and outputs results to JSON for analysis. 5.7 KB
CenterLoadStripComboShuffle.py CenterLoadStripComboShuffle.py - This file simulates the center load followed by strip shuffle combination to measure how quickly it randomizes card decks. It runs thousands of trials across different numbers of shuffles and compares the resulting disorder (measured by ascending sequence count) against the expected random distribution. 6.8 KB
CompareShuffleResults.py CompareShuffleResults.py - This script analyzes and compares results from different shuffle algorithms by loading JSON result files, calculating randomness percentages relative to a theoretical random baseline, and generating both a text report and visualization charts for each deck type. 4.5 KB
HeartCutShuffle.py HeartCutShuffle.py - This script simulates a "heart cut shuffle" variant where the middle portion of a deck is extracted and then riffle-shuffled with the combined top and bottom portions, measuring how many shuffles are needed to randomize the deck by counting rising card sequences. It runs experiments on different deck types (Standard 52-card and custom Skibbo 60-card) and outputs results to JSON files. 5.7 KB
Standard-Shuffle.py Standard-Shuffle.py - This script simulates riffle shuffles to measure how many shuffles are needed to randomize a card deck by tracking the decay of ascending card sequences. It tests multiple shuffle counts and deck types, outputting statistical results to JSON files for analysis. 4.7 KB
stripRiffleShuffle.py stripRiffleShuffle.py - This script simulates a card shuffling algorithm combining riffle and strip shuffles, running thousands of trials to measure how many shuffles are needed to randomize a deck. It outputs statistical results showing how rising sequences decay toward the expected random baseline for different deck configurations. 5.6 KB
StripShuffle.py StripShuffle.py - This file simulates the strip shuffle—a card-shuffling technique where packets are peeled off the top and dropped onto a growing pile in the other hand—to measure how many shuffles are needed to randomize a deck. It runs thousands of trials for different shuffle counts and tracks the average number of rising sequences (ascending card runs) as a metric of randomness, comparing results against a theoretical random baseline. 3.8 KB
TiltShuffle.py This script simulates a "tilt shuffle" technique that splits a deck unevenly (roughly 2/3 to 1/3) and interleaves the piles with random hand alternations, then measures how many shuffles it takes to randomize the deck by tracking rising sequences. It runs Monte Carlo trials on standard poker and Skibbo decks to empirically compare the shuffle quality against theoretical randomness. 5.3 KB
UndercutShuffle.py UndercutShuffle.py - This file simulates the undercut shuffle (a riffle shuffle preceded by cutting roughly the bottom third of the deck to the top) and measures how many shuffles are needed to achieve randomization on standard playing cards and Skibbo decks. It runs thousands of trials per shuffle count and tracks the decay of ascending card sequences as a metric for randomness. 5.4 KB

drafted by claude-haiku-4-5 + claude-sonnet-4-6 · 197.8k tokens · ≈$0.770 · corrected 5× · approved by a human