Les règles du Old Maid sont simples : c’est un bon exercice de programmation. Ici, on écrit en Python un programme qui joue seul des parties de Old Maid à quatre jusqu’au bout, puis on le lance 100 000 fois pour calculer des probabilités. Les règles sont les mêmes que dans l’appli Old Maid.

  • Les 53 cartes (un Joker) sont distribuées une à une aux 4 joueurs, en commençant par la place 0.
  • Une fois les premières paires défaussées par tous, on commence par la place 0.
  • L’ordre est place 0, 1, 2, 3, et l’on pioche une carte dans la main du joueur précédent. Ceux qui ont fini sont sautés.
  • Tout le monde pioche au hasard.
  • Quand il ne reste que le Joker, c’est fini.

Le programme

import random


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


def discard_pairs(hand):
    rest = []
    for card in hand:
        if card != 0 and card in rest:
            rest.remove(card)  # s’il y a la même valeur, on défausse les deux cartes
        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]:  # on saute ceux qui ont fini
            turn = (turn + 1) % players
            continue
        source = (turn - 1) % players  # on pioche chez le joueur précédent
        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)  # si une paire se forme, on la défausse
        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("Part des parties où le Joker reste (%) :", [round(c / games * 100, 1) for c in counts])
print("Nombre moyen de piochages :", round(total / games, 1))

Comment ça marche

La représentation des cartes

Les cartes sont représentées par leur seule valeur. L’As au Roi valent de 1 à 13, et le Joker vaut 0. Au Old Maid, la couleur (pique ou cœur) n’a pas d’importance pour former une paire : la valeur suffit. make_deck fabrique un paquet de 53 cartes, avec quatre exemplaires de chaque valeur de 1 à 13, plus un 0.

La distribution et les premières paires

deck[i::players] prend une carte sur quatre dans le paquet à partir de la i-ème. La place 0 reçoit les cartes numéro 0, 4, 8… : c’est comme si on distribuait une carte à la fois, à tour de rôle.

discard_pairs examine les cartes de la main une à une : si la même valeur est déjà là, elle défausse les deux cartes, sinon elle garde la carte. Avec trois cartes de même valeur, il en reste une ; avec quatre, il n’en reste aucune. Le Joker (0) ne forme jamais de paire.

L’ordre de jeu et le joueur chez qui l’on pioche

turn est la place dont c’est le tour. La place précédente se calcule avec (turn - 1) % players. % donne le reste de la division : la place précédant la place 0 est la place 3. Si le joueur précédent a fini, on pioche chez celui d’avant.

Si la main contient une carte de même valeur que la carte piochée, on défausse les deux cartes. Sinon, on l’ajoute à la main.

La fin et le résultat

La partie s’arrête quand le total des cartes de toutes les mains est de 1. Le joueur qui a encore une carte en main est celui qui a le Joker.

Le résultat

Avec random.seed(1) pour fixer la graine aléatoire, une exécution avec Python 3.14 a donné ceci.

Part des parties où le Joker reste (%) : [16.1, 28.7, 38.9, 16.2]
Nombre moyen de piochages : 31.9

La place 0 (vous, dans l’appli) et la place 3 (Oscar) ont environ 16 %, la place 1 (Leo) environ 29 % et la place 2 (Rose) environ 39 %. Même en piochant au hasard, l’écart selon la place est de plus du simple au double. Le nombre moyen de piochages est d’environ 32.

Ce résultat concorde avec celui de 200 000 parties calculées avec un autre programme. Pourquoi la place compte est expliqué dans Qui garde le Joker à la fin ?.

À vous d’essayer

  • En changeant le 4 de play(players=4), vous changez le nombre de joueurs. Adaptez alors le nombre d’éléments de counts au nombre de joueurs.
  • En décalant le i de deck[i::players], vous changez le joueur qui reçoit 14 cartes. Essayez de voir comment le résultat change.
  • Que se passe-t-il si, au lieu de random.randrange, on pioche toujours la carte tout à gauche ?