Quelles sont les chances de vaincre cet obscur jeu de solitaire ?

Question

J'ai une question à propos d'un jeu bizarre, inconnu (et peut-être impossible) qu'un ami m'a appris. Il s'agit d'un jeu de solitaire qui se joue avec un jeu de cartes normal de 52 cartes, mais il est étrangement difficile à battre. De plus, ni mon ami ni moi n'avons pu trouver la moindre référence à ce jeu dans tout l'Internet.

Je suis conscient que la question n'est pas forcément intéressante pour quelqu'un d'autre que mon ami et moi, mais je me demandais si quelqu'un serait prêt à m'aider à calculer les chances de battre ce jeu ? Je pense que cela nous aiderait à décider s'il s'agit d'un vrai jeu ou si c'est juste une farce bizarre que le père de mon ami (qui lui a appris le jeu) fait à plusieurs générations. Mes connaissances actuelles en mathématiques et en probabilités ne me permettent pas d'entreprendre ce projet seul.

Voici les règles :

Neuf colonnes de trois cartes ouvertes se chevauchant sont posées sur la table. La valeur faciale de chaque carte est utilisée pour calculer une somme avec les deux cartes les plus proches (en haut ou en bas) de la colonne et la dernière carte peut "s'enrouler" avec la carte du bas (la première jouée sur la colonne) pour atteindre une certaine somme si nécessaire. Les cartes visibles valent toutes 10 points.

A chaque tour, vous passez à la colonne "suivante" (cycliquement), vous placez une carte de la pioche en haut de cette colonne, puis, dans la même colonne, vous cherchez potentiellement trois cartes l'une après l'autre (deux en haut et une en bas, et une en haut et deux en bas, sont également valables) qui composent 9, 19 ou 29, puis, si vous les trouvez, vous retirez ces cartes et les placez en bas de la pioche, dans le même ordre.

Si d'autres combinaisons valides sont révélées après le retrait d'un triplet de cartes d'une colonne, elles sont également retirées et remises au fond du jeu.

Si toutes les cartes d'une colonne sont ainsi ramassées, la colonne est éliminée.

L'objectif théorique est de ramasser les neuf colonnes avant que la pioche ne s'épuise. Si la pioche s'épuise, le jeu est terminé.

Mon ami a joué à des milliers de jeux et n'a jamais battu ce jeu, ne serait-ce qu'une fois. Il s'y accroche uniquement parce que son propre père se vante de l'avoir terminé deux fois en trente ans de jeu... Mais il y a vraiment anguille sous roche.

Quelqu'un peut-il nous aider ?

Answer 1

En fonction de la disposition initiale du jeu, la partie se termine par une victoire ou une défaite, ou ne se termine jamais . Pour estimer les probabilités, j'ai simulé 10^8 parties (à l'aide du programme Python ci-dessous), selon deux règles différentes :

1. Après l'ajout d'une carte dans une colonne, seul le numéro de la carte est affiché. trois les triplés (en utilisant le wrap-around) qui incluent la carte ajoutée sont à considérer pour le retrait.
2. Après l'ajout d'une carte dans une colonne, todos les triplés (en utilisant le wrap-around) sont à considérer pour le retrait.

Voici les résultats :

                      with rule (1)              with rule (2)
                   --------------------      --------------------           
est.P(win)    =    0.000040 +- 0.000001      0.000043 +- 0.000001
est.P(loss)   =    0.999921 +- 0.000002      0.999914 +- 0.000002
est.P(cycle)  =    0.000039 +- 0.000001      0.000043 +- 0.000001

Cela suggère que le père de votre ami, pour gagner deux fois en 30 ans, aurait dû jouer environ 2/(.00004)= 50000 parties pendant cette période, ce qui représente plus de 4 parties par jour.

Il est intéressant de noter que certains arrangements rares du jeu permettent de gagner en moins de 100 coups, alors que d'autres (également rares) nécessitent plus de 1000 coups pour gagner ! Les jeux qui ne se termine pas peuvent également être intéressants, car ils peuvent ne commencer à faire des cycles qu'après plusieurs centaines de mouvements, et les cycles ont des durées variables (par exemple, 51, 96, ...).

---

Programme Python 3 (vous pouvez Essayez-le en ligne mais cela prend environ 50 secondes pour 10^5 jeux. J'ai exécuté mes 10^8 jeux en utilisant pygmée (ce qui est beaucoup plus rapide, mais a tout de même pris environ 2 heures) :

import random

deck0 = [i+1 for i in range(9)]*4 + [10]*16

def game():
# return the list of final columns ( or None if cycle, else [] if win, else nonempty if loss)
    deck = deck0[:]
    random.shuffle(deck)
    #print(f"starting deck = {deck}\n")

    # with cards from the deck, make 9 cols of 3 cards each 
    cols = []
    for i in range(9):
        cols += [deck[:3]]
        deck = deck[3:]

    nmoves = 0
    max_nmoves = 10**4  # assume cycling if nmoves > max_nmoves  (confirm this works in separate testing)
    #print(f"deck = {deck}\ncols = {cols}\n")

    c = -1    
    while cols and deck:

        nmoves += 1 
        if nmoves >= max_nmoves:
            return None  # signal that it's cycling

        # make the next col (with wrap-around) the current col
        c = (c + 1) % len(cols)

        # move one card from deck to current col
        cols[c] += [deck[0]]
        deck = deck[1:]

        done_col = False  # a flag for when finished processing the current column
        while not done_col: 
            # in current col, remove the first "good" triple (if any) to the deck (good := sum ends in 9)
            l = len(cols[c])
            if l < 3:
                break
            else:
                found_triple9 = False  # a flag for when a valid triple is found anywhere in this column
                #for triple_indices in [[l-3, l-2, l-1], [l-2, l-1, 0], [l-1, 0, 1]]:   #<-- rule(1)
                for triple_indices in [[i, (i+1) % l, (i+2) % l] for i in range(l)]:   #<-- rule(2)
                    triple = [cols[c][i] for i in triple_indices]
                    if sum(triple) % 10 == 9:
                        found_triple9 = True
                        # remove the triple from the column
                        cols[c] = [e for (i,e) in enumerate(cols[c]) if i not in triple_indices]
                        if cols[c] == []:  # delete the column if it's empty
                            del cols[c]
                            done_col = True
                            c -= 1  # <-- column-index adjustment due to deleting a column (omitted in previous version)
                        deck += triple
                        break 
                if not found_triple9:
                    done_col = True
        #print(f"nmoves={nmoves}\ndeck={deck}\ncols={cols}, c={c}\n")   
    return cols

import math

nsamp = 10**8
wins = 0
losses = 0
nonstops = 0
for i in range(nsamp):
    cols = game()
    if cols == None:
        nonstops += 1
    elif len(cols) == 0:
        wins += 1
    else:
        losses += 1

p_win = float(wins/nsamp)
p_loss = float(losses/nsamp)
p_cyc = float(nonstops/nsamp)
print(f"wins     = {wins:>10};  est.P(win)   = {p_win:8.6f} +- {1.96*math.sqrt(p_win*(1-p_win)/nsamp):8.6f}")
print(f"losses   = {losses:>10};  est.P(loss)  = {p_loss:8.6f} +- {1.96*math.sqrt(p_loss*(1-p_loss)/nsamp):8.6f}")
print(f"nonstops = {nonstops:>10};  est.P(cycle) = {p_cyc:8.6f} +- {1.96*math.sqrt(p_cyc*(1-p_cyc)/nsamp):8.6f}")
print(f"total    = {wins + losses + nonstops:>10}")

Note : Le programme permet de simuler l'une ou l'autre des règles (1) ou (2) en commentant simplement avec un "#" la ligne de code qui ne s'applique pas. (La règle (2) est maintenant la règle par défaut, mais son exécution prend presque deux fois plus de temps). Les règles telles qu'elles sont implémentées dans le programme déterminent complètement le résultat du jeu une fois que le paquet est mélangé.