La mona tiene reglas sencillas, así que es perfecta para practicar programación. Aquí haremos en Python un programa que juega solo una mona de 4 jugadores hasta el final y lo ejecutaremos 100 000 veces para calcular probabilidades. Las reglas son las mismas que en la app La Mona.

  • Se reparten 53 cartas (con un comodín) de una en una a 4 jugadores, empezando por el asiento 0.
  • Cuando todos han descartado sus primeros pares, empieza el asiento 0.
  • El orden es asiento 0 → 1 → 2 → 3, y cada uno roba una carta de la mano del jugador anterior. Se salta a quien ya ha salido.
  • Todos roban al azar.
  • La partida termina cuando solo queda un comodín.

El programa

import random


def make_deck():
    deck = [rank for rank in range(1, 14) for _ in range(4)]
    deck.append(0)  # 0 es el comodín
    return deck


def discard_pairs(hand):
    rest = []
    for card in hand:
        if card != 0 and card in rest:
            rest.remove(card)  # si ya hay un número igual, se descartan las dos
        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]:  # se salta a quien ya ha salido
            turn = (turn + 1) % players
            continue
        source = (turn - 1) % players  # se roba al jugador anterior
        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 forma un par, se descarta
        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("Porcentaje de veces que se quedó el comodín (%):", [round(c / games * 100, 1) for c in counts])
print("Media de robos:", round(total / games, 1))

Cómo funciona

Cómo se representan las cartas

Las cartas se representan solo con números. Del A al K son del 1 al 13, y el comodín es el 0. En la mona el palo (picas, corazones…) no influye en los pares, así que basta con el número. make_deck crea un mazo de 53 cartas con 4 cartas de cada número del 1 al 13 y un 0.

El reparto y los primeros pares

deck[i::players] toma las cartas del mazo de 4 en 4 empezando por la posición i. Al asiento 0 le tocan las cartas 0, 4, 8…, igual que si se repartiera de una en una.

discard_pairs mira las cartas de la mano una a una: si ya hay un número igual, descarta las dos, y si no, la deja. Con tres cartas del mismo número queda una y con cuatro no queda ninguna. El comodín (0) nunca forma par.

El orden y a quién se roba

turn es el asiento al que le toca. El asiento anterior se calcula con (turn - 1) % players. % es el resto de la división, así que el anterior al asiento 0 es el asiento 3. Si el anterior ya ha salido, se roba al de antes.

Si en la mano hay una carta con el mismo número que la robada, se descartan las dos. Si no, la carta se añade a la mano.

El final y el resultado

La partida termina cuando entre todas las manos suman una sola carta. Quien tiene esa carta es quien tiene el comodín.

Resultado de la ejecución

Fijando la semilla con random.seed(1) y ejecutando con Python 3.14, sale lo siguiente.

Porcentaje de veces que se quedó el comodín (%): [16.1, 28.7, 38.9, 16.2]
Media de robos: 31.9

El asiento 0 (tú en la app) y el asiento 3 (Óscar) tienen un 16 % aproximadamente, el asiento 1 (Leo) un 29 % y el asiento 2 (Rosa) un 39 %. Aunque se roba al azar, según el asiento hay una diferencia de más del doble. La media de robos es de unos 32.

Este resultado coincide con el de otro programa con el que calculamos 200 000 partidas. Por qué hay diferencias según el asiento lo explicamos en ¿A quién le toca quedarse con el comodín?.

Prueba a cambiarlo

  • Si cambias el 4 de play(players=4), cambia el número de jugadores. Al hacerlo, ajusta también el tamaño de counts.
  • Si cambias la i de deck[i::players], cambia quién recibe las 14 cartas. Prueba cómo cambia el resultado.
  • ¿Qué pasaría si, en lugar de random.randrange, se robara siempre la carta del extremo izquierdo?