How Many Possible Unique 90-Ball Bingo Cards Are There?

If you wanted to cheat at 90-Ball bingo then surely you could just print all the possible cards in advance and then produce the winning card after the the minimum number of balls have been called to get a full house?

The thing is that is not actually possible because it may surprise you but the number of possible number combinations on a 90-ball bingo card is actually huge, so big in fact that you could never possibly even get close to producing all the possible cards needed for a game.

We decided to look at how many theoretical unique 90-Ball bingo cards could be produced and the number comes out at:

24,069,639,359,475,000 or 24 Quadrillion possible unique 90-ball bingo cards.

Printing cards at 1 per second would mean we could print 31,536,600 cards per year (taking leap years into account), yet it would still take 763,228,736 years of constant printing to produce all the possible 90-ball bingo card combinations.  That is 15% of the time the planet earth has existed so far and if it was completed now printing would have started before any animals existed on the earth.

An average tree used to make paper produces around 10,000 sheets. Now let’s say 10 bingo cards on a single sheet, meaning each tree can produce 100,000 bingo cards.  To print all the possible cards for 90-ball bingo would require 240,696,393,595 (240 billion) trees to do this.  There are 3 trillion trees on the planet, meaning we would need 8% the world’s trees or 62% of the trees in the amazon just to complete this task.

In land based bingo cards are printed randomly and in online bingo random number generators are used to generate unique cards for each ticket purchased in a game.  It is fairly safe to say, if the game isn’t fixed of course, that the number of card combinations is sufficiently big to avoid any cheating in this regard.

You don’t have to take our word for it though, below we show you exactly how we worked out this crazy number and the logic behind it.  Warning there is some maths in there but as we were always told at school, make sure you show your working.

90-Ball Bingo Card Combinations

• Each card consists of 3 rows and 9 columns
• Each row has 5 numbers and 4 empty spots
• Columns contain: 1-9, 10-19, 20-29, 30-39, 40-49, 50-59, 60-69, 70-79, 80-90

An example bingo card:

How Many Possible 90-Ball Bingo Cards Are There?

That’s an interesting question, but a solvable one, with a bit of mathematics!

Firstly, we’re going to assume that we are only interested in cards which are distinct from one another within the game. So for example, if we had a card with the same numbers as the bingo card shown above, but with a slightly different layout (for example, the 21 on the bottom row and the 38 on the middle row), we will call those two identical, because they are within the game (two different players with these two cards would always win at the same instant).

Each card has 15 numbers, however the layout of the card alters the calculation for two reasons:

1. Firstly, different cards can pick a different number of the possibilities for each column (due to the different layout of the ‘blank’ cells)
2. Secondly, there are not the same number of possibilities for numbers in each column: there are only 9 possibilities for the first column (1-9) whilst there are ten possibilities for the other columns, except the ninth and final column which has eleven possibilities (80-90)

Therefore we break down calculating the number of possible bingo cards into two steps: firstly, we will work out how many distinct layouts there are (noting as above that we will ignore identical cards, therefore two layouts of blank cells that give the same number of selections per column will be considered as identical). Then, for each such unique layout, we will calculate how many possible selections of numbers there are.

Python Code Used For The Calculations

from itertools import combinations, combinations_with_replacement
from math import comb, prod
from typing import Set, Tuple

def all_row_layouts(columns: int, blanks_per_row: int) -> Set[Tuple[int, ...]]:
    """
    Calculate the different possibilities for laying out a row on the card.
    >>> all_row_layouts(columns=2, blanks_per_row=1)
    {(0, 1), (1, 0)}
    >>> len(all_row_layouts(columns=9, blanks_per_row=4))
    126
    """
    return {
        tuple(1 if col in selections else 0 for col in range(columns))
        for selections
        in combinations(range(columns), columns - blanks_per_row)
    }

def all_card_layouts(rows: int, columns: int, blanks_per_row: int) -> Set[Tuple[int, ...]]:
    """
    Calculate the different possibilities for laying out a card of the
    given number of rows and columns.
    >>> len(all_card_layouts(rows=3, columns=9, blanks_per_row=4))
    27876
    """
    return {
        tuple(sum(row[col] for row in combo) for col in range(columns))
        for combo
        in combinations_with_replacement(all_row_layouts(columns, blanks_per_row), rows)
    }

def possible_combos_for_layout(
    layout: Tuple[int, ...],
    possibilities_by_column: Tuple[int, ...]
) -> int:
    """
    Calculate the number of different possibilities for filling in a card
    with the given layout.
    >>> possible_combos_for_layout((2, 1, 2, 1, 2, 1, 2, 2, 2), (9, 10, 10, 10, 10, 10, 10, 10, 11))
    8119237500000
    """
    return prod(
        comb(possibilities_by_column[col], quantity)
        for col, quantity
        in enumerate(layout)
    )

def total_possible_cards(
    rows: int,
    columns: int,
    blanks_per_row: int,
    possibilities_by_column: Tuple[int, ...]
) -> int:
    """
    Calculate the total number of different possible bingo cards.
    """
    return sum(
        possible_combos_for_layout(layout, possibilities_by_column)
        for layout
        in all_card_layouts(rows, columns, blanks_per_row)
    )

total_possible_cards(
    rows=3,
    columns=9,
    blanks_per_row=4,
    possibilities_by_column=(9, 10, 10, 10, 10, 10, 10, 10, 11)
)