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:
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)
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.
Best Answer
The probability of winning depends on the way you choose the rows. To have a vague idea of the numbers you can look at what happens if each row is filled at random (this is clearly not optimal, for instance it includes the possibility that you use two identical rows).
For a single row, the probability of winning is the ratio of draws of 20 numbers out of 75 that include the 8 selected numbers in the row to the total number of draws of 20 numbers out of 75, i.e. $$ p=\frac{75-8 \choose 20-8}{75 \choose 20}= \frac{1}{133\,929}. $$ If you play $n$ rows, each independently and randomly selected, then the probability of winning is $$ 1-(1-p)^n. $$ If you want that to be $70~\%$ you solve for $n$: $$ 1-(1-p)^n=.7 \rightarrow n=161\,246. $$ This is clearly an upper bound, as a better strategy should do better that selecting rows at random.
Edit: details on the computation of $p$. Once you have chosen your 8 numbers, the number of draws of 20 numbers out of 75 that will make you a winner is the number of ways to pick your 8 numbers exactly (just one way) and then to pick the remaining 12 numbers out of the remaining 67 numbers: $1\times{67\choose12}$. The total number of ways to pick 20 numbers remains ${75\choose20}$. The probability is the ratio of favourable draws to total draws, thus the above formula.