# What makes a good alternative to flipping a coin for 50/50 randomness?

I'm building a coin-flip themed Commander deck, and I realise I'm going to be flipping potentially dozens of coins every turn deeper into a match.

What would be a good alternative to flipping an actual, physical coin that fits the following criteria?

1. Can be done many times quickly.
2. Serial, not parallel (not doing many at once, but many in order).
3. Requires minimal maths/mental effort.
4. Isn't "messy"; flipping a coin risks losing it across the room or under a table. I'd like to avoid similar issues.
5. Is a truly random 50/50 proposition.

Bonus points for fun and aesthetically pleasing answers.

• Is "parallel" okay if there is a way of telling the order of heads/tails? For example, a d8 and a lookup table can give you 3 ordered 50/50 results. Commented Aug 25, 2023 at 10:16
• I think while that's an interesting idea it violates the "minimum mental effort" part. It should be readily understood not just by me but by everyone at the table. Cool idea though! Commented Aug 25, 2023 at 10:23
• I'm not really sure that you can get anything simpler than "oh, rolled a 5, handy laminated card says thats HTT". Although you can get d16s :) Commented Aug 25, 2023 at 10:36
• Reading the entrails of a chicken? Commented Aug 26, 2023 at 18:56
• Commented Aug 28, 2023 at 10:38

Use a coinflip app, or physical 4- or 6-sided dice (calling odd/even or above/below half instead of heads/tails).

Both solutions fulfill all your criteria. You can further secure dice against falling off with a dice bowl or cup. Dice have the additional advantage of parallel flips, should the need arise despite your stipulation.

• Yep, just roll a bunch of dice, calling evens as "heads" and odds as "tails" (or vice-versa). They don't even all have to be the same kind, as long as they are have an even number of sides (all standard 4, 6, 8, 10, 12, or 20-sided dice would work). Commented Aug 25, 2023 at 16:31
• @TheThirdMan A PRNG is significantly more random than physically rolling dice, especially if they aren't casino quality. And either is far more random than actually needed for the purpose. Commented Aug 25, 2023 at 23:14
• @TheThirdMan modern PRNGs are practically indistinguishable from true RNGs. They are good enough for cryptography and regulated online gambling, so they're good enough for mtg coin flipping. Commented Aug 25, 2023 at 23:27
• @TheThirdMan modern phone processors actually have proper actual sources of randomness built into the hardware, and even if they didn't, the operating system can synthesize seemingly random bits from external events (read latencies, sensors, RF data,…) to produce excellent randomness. So, unless a dice roll app does something stupid (like not using the operating system-supplied random device to seed a PRNG, or to draw a number for the dice every time, because, well, human dice-requesting speed is quite slow and there's enough entropy in that system), consider a phone dice app a true RNG. Commented Aug 26, 2023 at 19:23
• @JackAidley I have advised theses on random number generation. You're being a bit grandiose towards Therac there; defaults actually are more than good enough: C++ (std::random, Mersenne Twister on 2¹⁹⁹³⁷-1), Java (java.util.random: L32X64MixRandom), JavaScript (Xoroshiro128+, which is so good while compact that we implemented it in hardware during one thesis), Python (Cpython:same MT19937 as C++), Swift (pre-4.2, people used arc4random, after which things got even better), rust (rand::rng, ChaCha 20 or 12).... Could you explain to me which language you're specifically referring to? Commented Aug 27, 2023 at 23:31

If you have a phone which has a sufficiently accurate stopwatch (probably hundredths of a second is good enough, thousandths would be better) such that you can't reliably stop the stopwatch on any single digit, you could just start and stop the stopwatch repeatedly and use the parity of the final digit (i.e. odd/even where odd=heads, even=tails).

• Not sure why this is being downvoted. It's a valid method and probably less easy to bias than a coin flip: ncbi.nlm.nih.gov/pmc/articles/PMC2789164 Commented Aug 26, 2023 at 0:51
• I mean, if you have a phone, you have a device with a true random number generator built in. Commented Aug 26, 2023 at 19:20
• @MarcusMüller - I don't quite follow your argument in your first comment. The advantage of this method is that it only requires a 'vanilla' phone - i.e. there is no need to install any additional software. Commented Aug 26, 2023 at 21:54
• Ah! I see your point; thanks for clarifying. Commented Aug 26, 2023 at 22:07
• @MarcusMüller Some theorists would object to the notion that any phone has a "true" random number generator in it. I’m no expert on randomness, although I’m not totally naive either, and I’m not able to follow your reasoning of why you think the stopwatch method is "less random" than another method. It seems like you’re saying it might be less random and since we’re not sure that it’s random means it’s not as good an answer? If so, I’d counter that the uncertainty about its randomness is part of its randomness and that seems like more than enough randomness for a game. It’s not crypto. Commented Aug 27, 2023 at 22:36

# Prologue: Why Randomness Is (Not) Hard in Real Life

Disclaimer: I might have designed too many probability theory basics exam questions in my life; whether this left permanent damage is up to you to judge.

What I really like is finding mechanical apparatus that behave randomly: That's slightly surprisingly a bit of a challenge: Our reality is full of true randomness, and unless you restrict yourself to (often rather artificially-feeling) experiments where that is really not the case (like drawing colored marbles from an urn without putting them back, or cards from a deck), you can model extremely many phenomena as truly 50/50.

Small problem is that these really random effects tend to happen on a microscopic or very weak level – you need some amplification to see them! That's why the computer (or phone) based answers are excellent: These devices both include true random number sources1,2: because they're anyways based on electronic logic dealing with very small phenomena, it's inherently possible to measure these small random effects and translate them into values observable by software. (People like to say that "randomness on a deterministic machine like a computer is hard", but that's not really the case. Millions are spent keeping the random behaviour out of a computer processor, each time one is designed, because the effects that make your computer work are really only a bit stronger than what noise you can expect. And that noise is random.)

# Building a Good Tosser

Good: Truly fair, truly uncorrelated, and most of all: fast and easy to use

Now, I think computers are cool; I really think that a neat little box with a small half-spherical dome on top where a small "coin" disk is spun on a horizontal axis by a motor, controlled by a 1€ microcontroller that takes a bit of truly random external input to compute nearly arbitrarily many random throws would be the nicest solution in terms of usability. Put a little momentary switch on the bottom of the box to trigger the "toss" with a satisfying *smack* on the top.
It will be quite hard to beat that in terms of fairness and uncorrelatedness, in addition of the ease-of-use³.

# Building a 🤌 Beautiful Randomification Device

But the hardcore usability and probability side ignored, what mechanical ways are there to amplify a small random effect in a way that stays really random.

Two devices that already exist come to mind:

## Magnetic Pendulum

Just like the actual coin toss, this isn't actually random: toss a coin twice in exactly the same way, it will land the same way. There's a deterministic input/output relationship. The thing is that humans just aren't great tossers, so that basically never happens in amateurs (whether someone could train to throw a coin reliably, I guess they could! Have you seen olympic archers?).

The main thing why "throwing a coin" seems fair is that the movement it makes for the methods we usually use when throwing seems chaotic, i.e., tiny changes in input conditions lead to very drastic changes in output.

Here's a picture of one possible implementation of a magnetic pendulum:

Source: Chalk Dust Magazine, Authors James Christian and Holly Middleton-Spencer, Link

You can build one with an even number of magnets, as well. It's very hard to predict from the initial position at which magnet the pendulum will end up; I found the simulation on this website very beautiful.

## Galton Board

Now, this is Fancy (capital F) and overkill, because in the form that you usually see it it's used to demonstrate what happens when you chain a lot of identical, but independent, random decisions:

Source User Matemateca (IME USP); CC-BY SA 4.0

The loads of balls are dropped through the narrow channel on top, each of them hits various pegs on the way down, and each time takes a random left or right. See the device in action here.

Of course, instead of throwing hundreds of balls at once, you could throw one down the chute (that ends up being a game quite similar to Pachinko), and base your head/tails decision on whether it comes out left or right.

Because you don't care to see the beautiful Gaussian distribution, just the half it comes out in, you could omit the outer pegs on the lower rows, where a deflection can no longer change the side the ball comes out.

Technically, of course, you would need but a single peg and a very precise chute for your ball, but keeping tolerances and sizes in check, at least a few pegs which stand a fair chance of cancelling bias is probably a good idea; also, more clang = more fun.

¹ on x86 (i.e., your laptop/desktop): `RDRAND`

² on ARM application processors (i.e., in your phone, your TV or your smart camera), you typically find peripherals that offer true physical random numbers at some address in memory space

³ I might be crazy enough that if someone funded me for that product development, I might be willing to undertake that engineering effort.

• Galton Board? PACHINKO! Commented Aug 28, 2023 at 8:28

Using either Microsoft Excel or Google Sheets, the formula =RANDBETWEEN(0,1) will give you 50/50 odds of a 0 or 1. On a PC, hit the delete key on an empty cell to re-roll (or F9 works in Excel too). I'm sure there's a Mac equivalent. Copy the cell to as many cells as you want if you want to see several re-rolls in order.

p.s., as others have stated with other answers, this answer is also PRNG, but it's practical and more than sufficient for your use case.

• You are right that pseudorandom generator is much better than a coin flip and probably takes less effort to defeat (depending on how terrible your PRNG is): ncbi.nlm.nih.gov/pmc/articles/PMC2789164 Commented Aug 26, 2023 at 0:52

A wonderfully horrible solution for RNG is an old-fashioned dice popper. They make for a literal pushbutton solution to RNG, with no dice falling off tables. They also make a sound that is either mildly annoying or just the right amount of kitsch, depending on your personality.

A very simple low-tech solution:

Use one or more decks of cards

• Shuffle the cards and lay face down.

• Turn the top card for a random 50/50 decision: red or black.

• Place in a discarded pile.

• Shuffle and restart when they run out.

Two suggestions to make the last card unpredicatable:

• Keep the Jokers in the pack and reshuffle when one is turned.

• Cut the pack after each shuffle and put one part out of play.

• Probably better to re-shuffle before it runs out. The closer you get to the end, the more predictable it gets, to the point that the last one is always 100% predictable (if somebody's willing to keep count of what's come up previously). Commented Aug 26, 2023 at 16:29
• @JerryCoffin yes, you would only need to track the parity to know the last card. I've added a solution. Commented Aug 26, 2023 at 17:34
• This is going to frequently violate OP's 5th condition. Whenever there's an odd number of cards remaining, you no longer have 50/50. And even when there's an even number remaining, you still might not have 50/50 depending on the previous draws Commented Aug 26, 2023 at 18:15
• @WeatherVane Your solutions don't fix the issue. Anytime you draw and reveal a card, you have new information to calculate new probabilities. Splitting the deck or shuffling early is irrelevant to this; all they do is limit how far you get before you start over. In other words, they stop you from reaching a point of 100% certainty most of the time. Here's actually a topic that illustrates this: stats.stackexchange.com/questions/569562/… You can update the equations there for colors instead of a specific card Commented Aug 26, 2023 at 19:00
• After the first draw, the distribution of the deck is 26:25, and no amount of cutting or reshuffling will change that, the second card (already) isn't 50-50. You'd have to shuffle the drawn card pack, or search through the deck for another of the opposite color also remove (and then shuffle anyway) to balance it. Or, if you don't want to do that, you should at least admit that it's biased. Even with a perfect shuffle (which could be taken as similar to a perfectly symmetrical shape, which is something we implicitly assume of dice anyway). Commented Aug 27, 2023 at 15:21

Use a spinner, like the one that comes with the popular "Game of Life" board game, except each of the numbers alternates with "heads" or "tails" (or whatever 2 categories you prefer). From personal experience, this is faster and less messy than flipping coins or rolling dice. And it's fun!

• Those spinners (especially the ones in Life game boards) were terrible. When I was a kid, ours had the wheel bearing far enough off center that about 1/3 of the wheel didn't even click on the tab, so the wheel couldn't stop at those numbers. If you want to use something that spins, find a well made dreidel. Commented Aug 29, 2023 at 12:31
• @ZeissIkon It's totally feasible to make a not-bad spinner though. A dreidel is not a bad idea, but IMO the downsides are similar to dice--except it trades messiness for time it takes to get a result. Commented Aug 30, 2023 at 7:38

Start an AC motor

When started, AC motors will rotate in a random direction (unless they're specifically designed to run in one direction).

Possibly the most obvious example of this is microwave turntables. Start a microwave (put a cup of water in it first), and if it's turning clockwise it's heads; anticlockwise tails.

If you can get your hands on such a motor without the surrounding microwave, you can probably come up with all sorts of fun embellishments for it.

• I have no idea how needing a motor with an AC source is somehow better than a coin flip. Commented Aug 28, 2023 at 5:59
• @Nelson Well, it meets all the criteria in the OP. Portability isn't one of them.
– BenM
Commented Aug 28, 2023 at 20:36
• You mean it completely doesn't fit 1 and 4? 1) Can be done many times quickly. 4) Isn't "messy"... Commented Aug 29, 2023 at 0:34
• My microwave reliably starts the turntable opposite the way it ran last (unless it's been unplugged or power was off); I think the internal controller is programmed for this. Most if not all of those use a stepper motor for that anyway. Commented Aug 29, 2023 at 12:56

EDIT: use cryptographically secure `os.urandom` for true randomness

### Python one-liner

You could install python and run the following command in your terminal

``````python3 -c 'import os; print(f"{int.from_bytes(os.urandom(1)):08b}")'
``````

Here you get `8` coin flips at once.

### Python file

For a bit more flexibility you can also save the following code as the file `coinflips.py`

``````#!/usr/bin/env python3

import os, sys

def flip_coins_n_times(n:int):
nbytes = n//8 + bool(n%8)
# get random bytes, convert to bits (including leading zeros)
# finally remove excess and print
print(f"{int.from_bytes(os.urandom(nbytes), 'big'):0{8*nbytes}b}"[0:n])

if __name__ == '__main__':
# file is run from commandline
flip_coins_n_times(int(sys.argv[1]))
``````

and run it from the command line as

``````\$ python3 coinflips.py 20
11100100011100100111
\$
``````

Here you can replace `20` by the number of coinflips you want

Use one or more decks of cards for a precise 50% outcome

• Define a set of rules so that given two cards one always "beats" the other (this could be a simple ordering or paper-scissors-rock-style non-transitive ordering to guarantee at least some suspense if the cards are revealed one at a time)

• Shuffle the cards and lay face down.

• Turn the top two cards (maybe one at a time to create more suspense!), and note whether first card beats second (outcome 1) or second beats first (outcome 2).

• Note that each outcome has exactly 50% probability, and this is easily observed / proved.

• Put BOTH cards in a discard pile.

• Keep taking pairs of cards for further 50% chances.

• Reshuffle when the cards run out.

Unlike the one-card solution, probabilities remain 50% until the end of the deck - someone counting cards will know what the last two cards are, and thus the outcome after only the first card is revealed, but not what order they're in.

For extra fun and/or aesthetic pleasure:

• rather than regular playing cards, use appropriately-themed cards with rules that make sense for the cards' theme about what beats what. There could even be multiple ways to compare the cards, with the player choosing which before revealing the cards (e.g. "highest strength stat wins").
• where outcomes are to be in favour of one player or another, split into two randomised decks instead of one, and each player draws from "their" deck to see who wins.
• While I agree this produces a 50% chance, I'm unconvinced this is actually going to be less hassle than flipping a bunch of coins, particularly as you're going to have to explain it to your opponents before every game. Commented Aug 29, 2023 at 10:09