Game — Word Bingo with Sets

By the end of this lesson you can:

• Model a bingo card as a set, and the words the caller has shouted as another set.
• Check for a win with one line: card <= called.
• Use random.sample() to deal a unique card from a bigger word bank.

Imagine a tiny bingo card with five words and a caller who's already shouted six.

card   = {"satay", "milo", "cendol", "kopi", "roti"}
called = {"milo", "ipoh", "satay", "kopi", "cendol", "roti"}

Has the card won? Don't loop. Use one set operator.

print(card <= called)

True

The three sets

Word Bingo is three sets and one loop:

• WORD_BANK — the big pool of words. The caller draws from here.
• card — the player's five-or-so words. A subset of the bank.
• called — every word shouted so far. Grows by one per turn.

The game ends when card <= called turns True.

Dealing a fair card · random.sample()

A bingo card must have no duplicates. random.sample(bank, k) picks k unique items from a collection. It returns a list — wrap it in set().

import random

WORD_BANK = ["satay", "milo", "cendol", "kopi", "roti",
             "ipoh", "kuala lumpur", "penang", "bandung",
             "rambutan", "durian", "kuih"]

card = set(random.sample(WORD_BANK, 5))
print("Your card:", card)

Run the file a few times — you'll see five fresh words each run.

The caller

The caller shouts one new word from the bank each turn — but never the same word twice. That's easy if we remove from a shuffled copy:

pool = list(WORD_BANK)
random.shuffle(pool)
# pool[0] is the first call, pool[1] the second, etc.

Putting it together — one round

Loop through the shuffled pool, adding each word to called. After every call, check the subset.

called = set()
turn = 0
for word in pool:
    turn += 1
    called.add(word)
    print("Call", turn, ":", word)
    if card <= called:
        print("BINGO! Won on turn", turn)
        break

card <= called is the entire win check. No loops, no flags, no counting.

What if you want progress?

To show how many of the card's words have come up so far — intersection counts:

hits = card & called
print("Matches so far:", len(hits), "/", len(card))
print("Still need    :", card - called)

Three set operators do the job that would otherwise need three loops.

Save this complete file as bingo.py and run it a few times.

Code

# bingo.py — one full round of Word Bingo

import random

WORD_BANK = [
    "satay", "milo", "cendol", "kopi", "roti canai",
    "ipoh", "kuala lumpur", "penang", "bandung",
    "rambutan", "durian", "kuih", "rendang", "asam",
    "nasi lemak", "teh tarik", "char kway teow",
]

# Deal a 5-word card and shuffle the pool
card = set(random.sample(WORD_BANK, 5))
pool = list(WORD_BANK)
random.shuffle(pool)

print("Your card:")
for w in card:
    print(" ★", w)
print()

called = set()
turn   = 0

for word in pool:
    turn += 1
    called.add(word)
    print("Turn", turn, "→", word)

    hits = card & called
    print("  Matches:", len(hits), "/", len(card))

    if card <= called:
        print()
        print("BINGO! Won on turn", turn, "✦")
        break

# After the loop — final report
print()
print("Final called list:", called)
print("Words on the card you never needed beyond the win:",
      called - card)

Sample output (yours will vary)

Your card:
 ★ satay
 ★ kuih
 ★ teh tarik
 ★ rambutan
 ★ kopi

Turn 1 → durian
  Matches: 0 / 5
Turn 2 → kopi
  Matches: 1 / 5
Turn 3 → asam
  Matches: 1 / 5
Turn 4 → satay
  Matches: 2 / 5
Turn 5 → rambutan
  Matches: 3 / 5
Turn 6 → ipoh
  Matches: 3 / 5
Turn 7 → cendol
  Matches: 3 / 5
Turn 8 → teh tarik
  Matches: 4 / 5
Turn 9 → nasi lemak
  Matches: 4 / 5
Turn 10 → kuih
  Matches: 5 / 5

BINGO! Won on turn 10 ✦

Final called list: {'durian', 'kopi', 'asam', 'satay', 'rambutan', 'ipoh', 'cendol', 'teh tarik', 'nasi lemak', 'kuih'}
Words on the card you never needed beyond the win: {'durian', 'asam', 'ipoh', 'cendol', 'nasi lemak'}

Three short exercises. Type each in a fresh file or as additions to bingo.py.

card = set(random.sample(WORD_BANK, 8))

card_a = set(random.sample(WORD_BANK, 5))
card_b = set(random.sample(WORD_BANK, 5))

called = set()
for turn, word in enumerate(pool, start=1):
    called.add(word)
    if card_a <= called and card_b <= called:
        print("Tie on turn", turn)
        break
    if card_a <= called:
        print("A wins on turn", turn)
        break
    if card_b <= called:
        print("B wins on turn", turn)
        break

shared    = card_a & card_b
unique_a  = card_a - card_b
print("Cards share :", len(shared), "word(s):", shared)
print("Only on A   :", unique_a)

Word Bingo is what set operators look like in a real game. The card and the called-words list are sets; the win is a subset check (card <= called); the progress line is the intersection (card & called); the "still need" line is the difference (card - called). Three operators replace what would otherwise be three small loops.