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:

- Firstly, different cards can pick a different number of the possibilities for each column (due to the different layout of the ‘blank’ cells)
- 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.

### Part 1: How many unique layouts are there?

Each row on a 90-ball bingo card contains 5 numbers and 4 blanks. Effectively we are making 5 choices from 9 possibilities.

Using the standard formula for the number of combinations…

(where n is the number of possibilities and r is the number of selections we are making, i.e. in our case n = 9 and r = 5), we are able to calculate that there are 126 such combinations for each row.

However, we have three rows, so we need to consider all the unique combinations over the 3 rows.

Using a computer program, we’re able to add the rows together and compare the unique selection patterns which exist from the 9 columns: there are 27,876 such combinations. We will need the details (how many numbers are in each column of the card) of all of these combinations when we put things together below.

### Part 2: How many possible selections for a given layout?

Let’s consider this example bingo card again:

If we take the layout of blanks on this card, there are still many possibilities for the different numbers that could be present: even in the fourth column where this example card has the number 38, that could have been any of 10 possibilities (30, 31, 32, 33, 34, 35, 36, 37, 38, or 39).

For columns with multiple selections, we can again use this formula:

Therefore in this example:

- In column 1, there are 36 possible combinations of two numbers we could select from the 9 possibilities
- In column 2, there are 10 possible selections
- In column 3, there are 45 possible combinations of two numbers we could select from the 10 possibilities
- In column 4, there are 10 possible selections
- In column 5, there are 45 possible combinations of two numbers we could select from the 10 possibilities
- In column 6, there are 10 possible selections
- In column 7, there are 45 possible combinations of two numbers we could select from the 10 possibilities
- In column 8, there are 45 possible combinations of two numbers we could select from the 10 possibilities
- In column 9, there are 55 possible combinations of two numbers we could select from the 11 possibilities

Therefore for this layout (and other gameplay-identical layouts with the same number of filled cells in each column) there are 8,119,237,500,000 possible combinations of numbers that could be present.

### Putting it together

We need to carry out the same exercise shown in part 2 for each possible layout of the card determined in part 1. The algorithm here is:

- Calculate all of the possible layouts (selections of 5 columns from 9 to contain a number) for a single row of the grid
- Calculate the set of unique additions of three such rows
- For each layout in the set, calculate the total number of combinations for filling in such a layout (as we did for the example above) and total these to determine the absolute number of unique possible bingo cards

Carrying out this calculation, we determine that there are over twenty-four quadrillion unique 90-ball bingo cards which could possibly exist – **24,069,639,359,475,000** to be precise!

## 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)
)
```