O Old Maid tem regras simples, ótimas para treinar programação. Aqui vamos fazer em Python um programa que joga sozinho, até o fim, uma partida de Old Maid com 4 jogadores, e jogá-lo 100 mil vezes para calcular as probabilidades. As regras são as mesmas do app Old Maid.

  • As 53 cartas (com 1 Coringa) são distribuídas uma a uma para 4 jogadores, começando pelo lugar 0.
  • Depois que todos descartam os primeiros pares, o jogo começa pelo lugar 0.
  • A ordem é lugar 0 → 1 → 2 → 3, e cada um puxa uma carta da mão do jogador anterior. Quem saiu é pulado.
  • Todos puxam ao acaso.
  • O jogo termina quando resta só 1 Coringa.

O programa

import random


def make_deck():
    deck = [rank for rank in range(1, 14) for _ in range(4)]
    deck.append(0)  # 0 is the Joker
    return deck


def discard_pairs(hand):
    rest = []
    for card in hand:
        if card != 0 and card in rest:
            rest.remove(card)  # if there is the same number, discard both cards
        else:
            rest.append(card)
    return rest


def play(players=4):
    deck = make_deck()
    random.shuffle(deck)
    hands = [discard_pairs(deck[i::players]) for i in range(players)]
    turn = 0
    draws = 0
    while sum(len(hand) for hand in hands) > 1:
        if not hands[turn]:  # skip players who are out
            turn = (turn + 1) % players
            continue
        source = (turn - 1) % players  # draw from the player before
        while not hands[source]:
            source = (source - 1) % players
        card = hands[source].pop(random.randrange(len(hands[source])))
        draws += 1
        if card != 0 and card in hands[turn]:
            hands[turn].remove(card)  # discard if a pair is made
        else:
            hands[turn].append(card)
        turn = (turn + 1) % players
    loser = next(i for i, hand in enumerate(hands) if hand)
    return loser, draws


random.seed(1)
games = 100000
counts = [0, 0, 0, 0]
total = 0
for _ in range(games):
    loser, draws = play()
    counts[loser] += 1
    total += draws
print("Share of games left with the Joker (%):", [round(c / games * 100, 1) for c in counts])
print("Average number of draws:", round(total / games, 1))

Como funciona

Como as cartas são representadas

As cartas são representadas só pelo número. De A a K são 1 a 13, e o Coringa é 0. No Old Maid o naipe (espadas, copas) não influencia os pares, então só o número basta. make_deck monta um baralho de 53 cartas, com 4 de cada número de 1 a 13 e 1 carta 0.

A distribuição e os primeiros pares

deck[i::players] pega as cartas do baralho a partir da posição i, de 4 em 4. O lugar 0 recebe as cartas de posição 0, 4, 8…, o que equivale a distribuir uma a uma em ordem.

discard_pairs olha as cartas da mão uma a uma e, se já houver um número igual, descarta as duas; se não, a carta fica. Com 3 cartas do mesmo número, sobra 1; com 4, sobram 0. O Coringa (0) nunca forma par.

A ordem e de quem puxar

turn é o lugar da vez. O lugar anterior é (turn - 1) % players. % é o resto da divisão, então o anterior ao lugar 0 é o lugar 3. Se o jogador anterior já saiu, você puxa do jogador antes dele.

Se a mão tem uma carta de número igual ao da puxada, as duas são descartadas. Se não, a carta é acrescentada à mão.

O fim e o resultado

O jogo termina quando o total de cartas das mãos chega a 1. Quem ainda tem uma carta na mão é quem está com o Coringa.

Resultado

Fixando a semente aleatória com random.seed(1) e executando no Python 3.14, obtivemos:

Share of games left with the Joker (%): [16.1, 28.7, 38.9, 16.2]
Average number of draws: 31.9

O lugar 0 (você, no app) e o lugar 3 (Oscar) ficaram com cerca de 16%, o lugar 1 (Leo) com cerca de 29% e o lugar 2 (Rosa) com cerca de 39%. Mesmo puxando ao acaso, há uma diferença de mais de duas vezes conforme o lugar. A média de puxadas é de cerca de 32.

Esse resultado também bate com o de 200 mil partidas calculadas por outro programa. Por que o lugar faz diferença está explicado em Quem fica com o Coringa no fim?.

Experimente mudar

  • Mudando o 4 de play(players=4), você muda o número de jogadores. Ao mudar, ajuste também o tamanho de counts ao número de jogadores.
  • Deslocando o i de deck[i::players], muda quem recebe as 14 cartas. Teste como o resultado muda.
  • E se, em vez de random.randrange, você puxasse sempre a carta da ponta esquerda?