[Math] How to calculate the odds of a 5×5 Bingo game

probability

I don't have a mathematics background, but am trying to calculate what the theoretical odds of winning a 5×5 bingo game is if 5 numbers are drawn.

Eg board:

01, 02, 03, 04, 05
06, 07, 08, 09, 10
11, 12, 13, 14, 15
16, 17, 18, 19, 20
21, 22, 23, 24, 25

If each number on the board is a unique number, and numbers can be from 01-75, how does one calculate the odds of getting 5 numbers in a row diagonally or accross? I am not looking for the answer, but rather how someone goes about calculating such odds. Without any knowledge of stats, all I can think of is:

75*74*72*72 etc… 12 times. My thinking in this is that each space must have a number, and that that number can be anything from 1 – 75. There are 12 winning combinations, eg:

--A B C D E
1 x x x x x
2 x x x x x
3 x x x x x
4 x x x x x
5 x x x x x

One could win by getting everything in column A, B, C D, or E, or by row 1, 2, 3, 4, 5, or the diagnals.

Yet somehow the odds being 1 in over a billion seem very off to me.

Best Answer

As Peter has pointed out in a comment, there are

$$ \binom{75}5=\frac{75\cdot74\cdot73\cdot72\cdot71}{5\cdot4\cdot3\cdot2\cdot1}=17259390 $$

possibilities to draw $5$ numbers out of $75$. Your calculation didn't take into account that you can draw the numbers in any of $5!=120$ different orders.

If you were drawing $9$ or more balls, you'd have to take into account that more than one of the Bingo opportunities can be realized, but as you're only drawing $5$ balls, they're all mutually exclusive, so you can just multiply the chance of $1$ in $17259390$ by the number of Bingo opportunities. I don't know how you came up with $15$ for this, and I'm not sure what you mean by "across", but if you allow horizontal, vertical and diagonal Bingos (like in real Bingo), then there are $5$ horizontal, $5$ vertical and $2$ diagonal Bingo opportunities, for a total of $12$, so the probability of getting a Bingo with $5$ balls drawn is

$$ \frac{12}{17259390}=\frac2{2876565}\approx7\cdot10^{-7}\;, $$

or slightly less than one in a million.

Related Solutions

[Math] BINGO Probability: Controlling average game duration

Yes, but it can not be made arbitrarily small. As the number of players increases, the expected number of turns to finish the game will approach $4$.
Yes it would, the average game length can be made arbitrarily long if enough numbers are used for the balls. The exact relationship is probably very complicated.

I've opted for a numerical approach, since the probabilities for BINGO are extremely not obvious. I wrote a Python program which (approximately) answers the question: "How many total numbers do we need to make a game last Nturns given that we have Nplayers people playing?" Note that the number of numbers needs to be a multiple of $5$, otherwise one column would be biased. Since $50$ turns seems to be a good average length for a game, if we just set $R = 50$, I've found an experimental fit for $1\leq P \leq 100$. See this graph:

Experimental fit

Note that to answer your example question, the model gives $N \approx 256.5$, so we probably need $255$ numbers. Here is the program if you want to compute some results more accurately; simply change the arguments of how_many_numbers(Nplayers, Nturns).

from random import shuffle, sample

# General plan: card represented as 5x5 arrays of ints, with
# filled spaces represented by 0's and called numbers being
# represented by [column number, actual number].
# Bingo is obtained with straight lines (including diagonals)

def generate_card(N): # makes fresh card with N numbers (mod 5)
    N_per_col = N/5 # numbers per column
    card = []
    for x in range(0, 5):
        card.append(sample(range(1 + x*N_per_col, N_per_col + 1 + x*N_per_col), 5))
    card[2][2] = 0 # free space
    return card


def generate_draws(N): # makes randomized list of balls to be drawn 
    # for N numbers/card (mod 5)
    N_per_col = N/5
    draws = []
    for x in range(0, 5):
        for y in range(1 + x*N_per_col, N_per_col + 1 + x*N_per_col):
            draws.append([x, y])
    shuffle(draws)
    return draws


def did_i_win(card, filled): # simulates player checking
    # whether or not they won after adding "filled". Player
    # only checks the row an column of the last number he filled,
    # or the diagonal if necessary.
    for column in range(0, 5):
        if card[filled[0]][column] != 0:
            for row in range(0, 5):
                if card[row][filled[1]] != 0:
                    if filled[0] == filled[1] or filled[0] + filled[1] == 4:
                        for x in range(0, 5):
                            if card[x][x] != 0:
                                    for y in range(0, 5):
                                        if card[y][4 - y] != 0:
                                            return 0
                                    return 1
                        return 1
                    else:
                        return 0
            return 1
    return 1


def update_card(mycard, called): # simulates player
    # updating all their cards with the most
    # recently called number; returns 1 if BINGO
    newcard = mycard
    for row in range(0, 5):
        if newcard[called[0]][row] == called[1]:
            newcard[called[0]][row] = 0
            if did_i_win(newcard, [called[0], row]) == 1:
                return 1
    return newcard


def grid_print(card): # Prints a card out as a grid, only used for debugging
    for x in range(0, 5):
        print card[0][x], card[1][x], card[2][x], card[3][x], card[4][x]


def play_game(Nplayers, Nnumbers): # Simulates the players playing a game,
    # returns the number of turns taken for the game to finish
    hands = [] # all players' hands
    for x in range(0, Nplayers):
        hands.append(generate_card(Nnumbers))
    undrawn = generate_draws(Nnumbers) # balls in wheel
    Nturns = 0
    while True: # while no one has won
        Nturns = Nturns + 1
        card = undrawn.pop(0) # Ball drawn and discarded
        for x in range(0, Nplayers): # Players update their hands
            hands[x] = update_card(hands[x], card)
            if hands[x] == 1: # if a player won
                return Nturns


def Exp_N(Ntrials, Nplayers, Nnumbers): # Runs Ntrials simulations and returns 
    # the expected number of turns until a bingo is reached in a game with 
    # Nplayers players and Nnumbers available for the cards
    turns = 0
    for x in range(0, Ntrials):
        turns = turns + play_game(Nplayers, Nnumbers)
    return float(turns)/Ntrials


def how_many_numbers(Nplayers, Nturns): # Determines how many numbers 
    # are needed for a game with Nplayers to last Nturns
    N = 25
    while True:
        Nturns_N = Exp_N(10, Nplayers, N) # change the 10 to 100 for greater accuracy
        if Nturns_N > Nturns:
            best_N = N
            score = abs(Nturns_N - Nturns)
            for N2 in range(N - 25, N + 25 + 1, 5):
                d = abs(Exp_N(100, Nplayers, N2) - Nturns) # change the 100 to 
                # 1000 for greater accuracy
                if d < score:
                    best_N = N2
                    score = d
            return best_N

        N = N + 5

print how_many_numbers(1, 42)

[Math] How to calculate the odds that the odds will be right

The number of ways, in a deck of $n$ cards, to win this game (out of the $n!$ total ways for the deck to have been shuffled) is given in OEIS as sequence A144188.

Playing with only 13 cards your chances of winning are about 5.246%.

Playing with half a deck, yet using suit order to break ties, your chances are down to 0.095%. What I find amazing is that this is much less than the square of the chances for a 13-card deck (which we would expect because it involves 25 guesses and the 13-card deck involves only 12) and is even 1.6 times less than the square of the winning chances with a 14 card deck and is less than the chances of winning two consecutive games, with a 15 card deck and a 14 card deck.

For large $n$ the chances of winning drop off by about a factor of 0.737 for each additional guess needed.

Best Answer

Related Solutions

[Math] BINGO Probability: Controlling average game duration

[Math] How to calculate the odds that the odds will be right

Related Question