#!/usr/bin/env python
# coding: utf-8

# # Simulons le jeu de *151* avec Python !
# 
# ## But :
# - Simuler numériquement le jeu de 151, qui est une variante à 3 dés du jeu appelé [5000](https://fr.wikipedia.org/wiki/5000),
# - Afin de trouver une stratégie *optimale*.
# 
# ## Comment ?
# - On va simuler des millions de parties (cf. [méthodes de Monte-Carlo](https://fr.wikipedia.org/wiki/Méthodes_de_Monte-Carlo)),
# - Afin de comparer différentes stratégies (aléatoires, s'arrêter au premier coup, s'arrêter après 3 coups, etc),
# - On les compare en fonction de leur gain *moyen*,
# - La meilleur stratégie sera celle qui apporte un gain moyen le plus élevé.
# 
# ## Résultats ?
# → Lien vers les résultats obtenus.

# ----
# 
# ## Plans
# 1. fonctions pour simuler un tirage (3 dés),
# 2. puis simuler une une partie (affrontant deux stratégies, face à un total), plein de parties (total aléatoire),
# 3. implémenter différentes stratégies,
# 4. les comparer, faire des graphiques, et tirer des conclusions statistiquement valides (avec moyennes *et* écart-types).

# ----
# 
# ## 1. Simuler un tirage et une partie

# ### 1.1. Simuler un tirage

# Dépendances :

# In[1]:


import numpy as np
import numpy.random as rn
rn.seed(0)  # Pour obtenir les mêmes résultats
import matplotlib.pyplot as plt

import seaborn as sns
sns.set(context="notebook", style="darkgrid", palette="hls", font="sans-serif", font_scale=1.4)


# Première fonction : pour tirer trois dés, à 6 faces, indépendants.

# In[2]:


def tirage(nb=1):
    """ Renvoie un numpy array de taille (3,) si nb == 1, sinon (nb, 3)."""
    if nb == 1:
        return rn.randint(1, 7, 3)
    else:
        return rn.randint(1, 7, (nb, 3))


# Testons là :

# In[3]:


tirage()


# In[4]:


tirage(10)


# ### 1.2. Points d'un tirage
# Le jeu de *151* associe les points suivants, multiples de 50, aux tirages de 3 dés :
# 
# - 200 pour un brelan de 2, 300 pour un brelan de 3, .., 600 pour un brelan de 6, 700 pour un brelan de 1,
# - 100 pour chaque 1, si ce n'est pas un brelan,
# - 50 pour chaque 5, si ce n'est pas un brelan.

# In[5]:


COMPTE_SUITE = False  # Savoir si on implémente aussi la variante avec les suites

def _points(valeurs, compte_suite=COMPTE_SUITE):
    if valeurs[0] == valeurs[1] == valeurs[2]:  # Un brelan !
        if valeurs[0] == 1:
            return 700
        else:
            return 100 * valeurs[0]
    else:            # Pas de brelan
        # Code pour compter les suites :
        bonus_suite = compte_suite and set(np.diff(np.sort(valeurs))) == {1}
        return 100 * (np.sum(valeurs == 1) + bonus_suite) + 50 * np.sum(valeurs == 5)


def points(valeurs, compte_suite=COMPTE_SUITE):
    """ Calcule les points du tirage correspondant à valeurs.
    
    - si valeurs est de taille (3,), renvoie un seul entier,
    - si valeurs est de taille (nb, 3), renvoie un tableau de points.
    """
    if len(np.shape(valeurs)) > 1:
        return np.array([_points(valeurs[i,:], compte_suite) for i in range(np.shape(valeurs)[0])])
    else:
        return _points(valeurs, compte_suite)


# #### 1.2.1. Un seul tirage

# Testons ces fonctions :

# In[6]:


valeurs = tirage()
print("La valeur {} donne {:>5} points.".format(valeurs, points(valeurs)))


# In[7]:


for _ in range(20):
    valeurs = tirage()
    print("- La valeur {} donne {:>5} points.".format(valeurs, points(valeurs)))


# Testons quelques valeurs particulières :

# - Les brelans :

# In[8]:


for valeur in range(1, 7):
    valeurs = valeur * np.ones(3, dtype=int)
    print("- La valeur {} donne {:>5} points.".format(valeurs, points(valeurs)))


# - Les 1 :

# In[9]:


for valeurs in [np.array([2, 3, 6]), np.array([1, 3, 6]), np.array([1, 1, 6])]:
    print("- La valeur {} donne {:>5} points.".format(valeurs, points(valeurs)))


# - Les 5 :

# In[10]:


for valeurs in [np.array([2, 3, 6]), np.array([5, 3, 6]), np.array([5, 5, 6])]:
    print("- La valeur {} donne {:>5} points.".format(valeurs, points(valeurs)))


# → C'est bon, *tout* marche !
# 
# *Note* : certaines variants du 151 accordent une valeur supplémentaire aux *suites* (non ordonnées) : [1, 2, 3] vaut 200, [2, 3, 4] vaut 100, et [3, 4, 5] et [4, 5, 6] vaut 150.
# Ce n'est pas difficile à intégrer dans notre fonction `points`.

# - Testons quand même les suites :

# In[11]:


for valeurs in [np.array([1, 2, 3]), np.array([2, 3, 4]), np.array([3, 4, 5]), np.array([4, 5, 6])]:
    print("- La valeur {} donne {:>5} points.".format(valeurs, points(valeurs)))


# #### 1.2.2. Plusieurs tirages

# Testons ces fonctions :

# In[12]:


valeurs = tirage(10)
print(valeurs)
print(points(valeurs))


# ----
# 
# #### 1.2.3. Moyenne d'un tirage, et quelques figures

# On peut faire quelques tests statistiques dès maintenant :

# - Points moyens d'un tirage :

# In[13]:


def moyenneTirage(nb=1000):
    return np.mean(points(tirage(nb), False))

def moyenneTirage_avecSuite(nb=1000):
    return np.mean(points(tirage(nb), True))

for p in range(2, 7):
    nb = 10 ** p
    print("- Pour {:>7} tirages, les tirages valent en moyenne {:>4} points.".format(nb, moyenneTirage(nb)))
    print("- Pour {:>7} tirages, les tirages valent en moyenne {:>4} points si on compte aussi les suites.".format(nb, moyenneTirage_avecSuite(nb)))


# Ça semble converger vers 85 : en moyenne, un tirage vaut entre 50 et 100 points, plutôt du côté des 100.
# Et si on compte les suites, la valeur moyenne d'un tirage vaut plutôt 96 points (ça augmente comme prévu, mais ça augmente peu).

# - Moyenne et écart type :

# In[14]:


def moyenneStdTirage(nb=1000):
    pts = points(tirage(nb))
    return np.mean(pts), np.std(pts)

for p in range(2, 7):
    nb = 10 ** p
    m, s = moyenneStdTirage(nb)
    print("- Pour {:>7} tirages, les tirages valent en moyenne {:6.2f} +- {:>6.2f} points.".format(nb, m, s))


# - Quelques courbes :

# In[15]:


def plotPoints(nb=2000):
    pts = np.sort(points(tirage(nb)))
    m = np.mean(pts)
    plt.figure()
    plt.plot(pts, 'ro')
    plt.title("Valeurs de {} tirages. Moyenne = {:.2f}".format(nb, m))
    plt.show()


# In[16]:


plotPoints()


# In[17]:


plotPoints(10**5)


# In[18]:


plotPoints(10**6)


# - On peut calculer la probabilité d'avoir un tirage valant 0 points :

# In[19]:


def probaPoints(nb=1000, pt=0, compte_suite=COMPTE_SUITE):
    pts = points(tirage(nb), compte_suite)
    return np.sum(pts == pt) / float(nb)


# In[20]:


for p in range(2, 7):
    nb = 10 ** p
    prob = probaPoints(nb, compte_suite=False)
    print("- Pour {:>7} tirages, il y a une probabilité {:7.2%} d'avoir 0 point.".format(nb, prob))
    prob = probaPoints(nb, compte_suite=True)
    print("- Pour {:>7} tirages, il y a une probabilité {:7.2%} d'avoir 0 point si on compte les suites.".format(nb, prob))


# Donc un tirage apporte 85 points en moyenne, mais il y a environ 28% de chance qu'un tirage rate.
# 
# Si on compte les suites, un tirage apporte 97 points en moyenne, mais il y a environ 25% de chance qu'un tirage rate.

# - On peut faire le même genre de calcul pour les différentes valeurs de points possibles :

# In[21]:


# valeursPossibles = list(set(points(tirage(10000))))
valeursPossibles = [0, 50, 100, 150, 200, 250, 300, 400, 500, 600, 700]


# In[22]:


for p in range(4, 7):
    nb = 10 ** p
    tirages = tirage(nb)
    pts   = points(tirages, False)
    pts_s = points(tirages, True)
    print("\n- Pour {:>7} tirages :".format(nb))
    for pt in valeursPossibles:
        prob = np.sum(pts   == pt) / float(nb)
        print("  - Il y a une probabilité {:7.2%} d'avoir {:3} point{}.".format(prob, pt, 's' if pt > 0 else ''))
        prob = np.sum(pts_s == pt) / float(nb)
        print("  - Il y a une probabilité {:7.2%} d'avoir {:3} point{} si on compte les suites.".format(prob, pt, 's' if pt > 0 else ''))


# On devrait faire des histogrammes, mais j'ai la flemme...
# 
# Ces quelques expériences montrent qu'on a :
# - une chance d'environ 2.5% d'avoir plus de 300 points (par un brelan),
# - une chance d'environ 9%   d'avoir entre 200 et 300 points,
# - une chance d'environ 11%  d'avoir 150 points,
# - une chance d'environ 27%  d'avoir 100 points,
# - une chance d'environ 22%  d'avoir 50  points,
# - une chance d'environ 28%  d'avoir 0   point.
# 
# Autant de chance d'avoir 100 points que 0 ? Et oui !
# 
# La variante comptant les suites augmente la chance d'avoir 200 points (de 7.5% à 10%), d'avoir 150 points (de 11% à 16%), et diminue la chance d'avoir 0 point, mais ne change pas vraiment le reste du jeu.

# ----
# 
# ### 1.3. Simuler des parties
# #### 1.3.1. Simuler une partie
# On va d'abord écrire une fonction qui prend deux joeurs, un total, et simule la partie, puis donne l'indice (0 ou 1) du joueur qui gagne.

# In[13]:


DEBUG = False  # Par défaut, on n'affiche rien


# In[14]:


def unJeu(joueur, compte, total, debug=DEBUG):
    accu = 0
    if debug: print("  - Le joueur {.__name__} commence à jouer, son compte est {} et le total est {} ...".format(joueur, compte, total))
    t = tirage()
    nbLance = 1
    if points(t) == 0:
        if debug: print("    - Hoho, ce tirage {} vallait 0 points, le joueur doit arrêter.".format(t))
        return 0, nbLance
    if debug: print("    - Le joueur a obtenu {} ...".format(t))
    while compte + accu <= total and joueur(compte, accu, t, total):
        accu += points(t)
        t = tirage()
        nbLance += 1
        if debug: print("    - Le joueur a décidé de rejouer, accumulant {} points, et a ré-obtenu {} ...".format(accu, t))
        if points(t) == 0:
            if debug: print("    - Hoho, ce tirage {} vallait 0 points, le joueur doit arrêter.".format(t))
            break
    accu += points(t)
    if compte + accu > total:
        if debug: print("  - Le joueur a dépassé le total : impossible de marquer ! compte = {} + accu = {} > total = {} !".format(compte, accu, total))
        return 0, nbLance
    else:
        if accu > 0:
            if debug: print("  - Le joueur peut marquer les {} points accumulés en {} lancés !".format(accu, nbLance))
        return accu, nbLance


def unePartie(joueurs, total=1000, debug=DEBUG, i0=0):
    assert len(joueurs) == 2, "Erreur, seulement 2 joueurs sont acceptés !"
    comptes  = [0, 0]
    nbCoups  = [0, 0]
    nbLances = [0, 0]
    scores   = [[0], [0]]
    if debug: print("- Le joueur #{} va commencer ...".format(i0))
    i = i0
    while max(comptes) != total:  # Tant qu'aucun joueur n'a gagné
        nbCoups[i] += 1
        if debug: print("- C'est au joueur #{} ({.__name__}) de jouer, son compte est {} et le total est {} ...".format(i, joueurs[i], comptes[i], total))
        accu, nbLance = unJeu(joueurs[i], comptes[i], total, debug)
        nbLances[i] += nbLance
        if accu > 0:
            comptes[i] += accu
            scores[i].append(comptes[i])  # Historique
        if comptes[i] == total:
            if debug: print("- Le joueur #{} ({.__name__}) a gagné en {} coups et {} lancés de dés !".format(i, joueurs[i], nbCoups[i], nbLances[i]))
            if debug: print("- Le joueur #{} ({.__name__}) a perdu, avec un score de {}, après {} coups et {} lancés de dés !".format(i^1, joueurs[i^1], comptes[i^1], nbCoups[i^1], nbLances[i^1]))
            return i, scores
        i ^= 1  # 0 → 1, 1 → 0 (ou exclusif)

# Note : on pourrait implémenter une partie à plus de 2 joueurs


# ----
# #### 1.3.2. Des stratégies
# 
# On doit définir des stratégies, sous la forme de fonctions `joueur(compte, accu, t, total)`, qui renvoie `True` si elle doit continuer à jouer, ou `False` si elle doit marquer.
# 
# D'abord, deux stratégies un peu stupides :

# In[15]:


def unCoup(compte, accu, t, total):
    """ Stratégie qui marque toujours au premier coup, peu importe le 1er tirage obtenu."""
    return False  # Marque toujours !

def jusquauBout(compte, accu, t, total):
    """ Stratégie qui ne marque que si elle peut gagner exactement ."""
    if compte + accu + points(t) >= total:
        return False  # Marque si elle peut gagner
    else:
        return True   # Continue à jouer


# Une autre stratégie, qui marche seulement si elle peut marquer plus de X points (100, 150 etc).
# C'est la version plus "gourmande" de `unCoup`, qui marque si elle a plus de 50 points.

# In[16]:


def auMoinsX(X):
    def joueur(compte, accu, t, total):
        """ Stratégie qui marque si elle a eu plus de {} points.""".format(X)
        if accu + points(t) >= X:
            return False  # Marque si elle a obtenu plus de X points
        elif compte + accu + points(t) == total:
            return False  # Marque si elle peut gagner
        elif total - compte < X:
            # S'il reste peu de points, marque toujours
            # (sinon la stratégie d'accumuler plus de X points ne marche plus)
            return False
        else:
            return True   # Continue de jouer, essaie d'obtenir X points
    joueur.__name__ = "auMoins{}".format(X)  # Triche sur le nom
    return joueur

auMoins50  = auMoinsX(50)    # == unCoup, en fait
auMoins100 = auMoinsX(100)
auMoins150 = auMoinsX(150)
auMoins200 = auMoinsX(200)   # Commence à devenir très audacieux
auMoins250 = auMoinsX(250)
auMoins300 = auMoinsX(300)   # Compètement fou, très peu de chance de marquer ça ou plus!
auMoins350 = auMoinsX(350)
auMoins400 = auMoinsX(400)
auMoins450 = auMoinsX(450)
auMoins500 = auMoinsX(500)
auMoins550 = auMoinsX(550)
auMoins600 = auMoinsX(600)
auMoins650 = auMoinsX(650)
auMoins700 = auMoinsX(700)
# On pourrait continuer ...
auMoins800 = auMoinsX(800)
auMoins850 = auMoinsX(850)
auMoins900 = auMoinsX(900)
auMoins950 = auMoinsX(950)
auMoins1000 = auMoinsX(1000)


# Une autre stratégie "stupide" : décider aléatoirement, selon une loi de Bernoulli, si elle continue ou si elle s'arrête.

# In[17]:


def bernoulli(p=0.5):
    def joueur(compte, accu, t, total):
        """ Marque les points accumulés avec probabilité p = {} (Bernoulli).""".format(p)
        return rn.random() > p
    joueur.__name__ = "bernoulli_{:.3g}".format(p)
    return joueur


# ----
# #### 1.3.3. Quelques exemples
# Essayons de faire jouer deux stratégies face à l'autre.

# In[18]:


joueurs = [unCoup, unCoup]
total = 200

unePartie(joueurs, total, True)
unePartie(joueurs, total)


# In[29]:


joueurs = [unCoup, jusquauBout]
total = 200
unePartie(joueurs, total)


# In[30]:


joueurs = [unCoup, auMoins100]
total = 500
unePartie(joueurs, total)


# In[31]:


joueurs = [unCoup, auMoins200]
total = 1000
unePartie(joueurs, total)


# ----
# 
# #### 1.3.4. Générer plusieurs parties
# On peut maintenant lancer plusieurs centaines de simulations de parties, sans afficher le déroulement de chaque parties.
# La fonction `unePartie` renvoie un tuple, `(i, comptes)`, où :
# - `i` est l'indice (0 ou 1) du joueur ayant gagné la partie,
# - et `comptes` est une liste contenant les deux historiques des points des deux joueurs.

# Par exemple, pour un `total = 500`, la sortie `(1, [[0, 100, 150, 250, 450], [0, 50, 450, 500]])` signifie :
# - le joueur 1 a gagné, après avoir marqué 50 points, puis 400, et enfin 50,
# - le joueur 2 a perdu, après avoir marqué 100 points, puis 50, puis 100, puis 200, mais a perdu avec 450 points.

# In[57]:


def desParties(nb, joueurs, total=1000, i0=0):
    indices, historiques = [], []
    for _ in range(nb):
        i, h = unePartie(joueurs, total=total, i0=i0, debug=False)
        indices.append(i)
        historiques.append(h)
    return indices, historiques


# Par exemple, on peut opposer le joueur pas courageux (`unCoup`) au joueur très gourmand (`jusquauBout`) sur 100 parties avec un total de 250 points :

# In[33]:


def freqGain(indiceMoyen, i):
    # (1^i) + ((-1)**(i==0)) * indiceMoyen
    if i == 0:
        return 1 - indiceMoyen
    else:
        return indiceMoyen


# In[56]:


def afficheResultatsDesParties(nb, joueurs, total, indices, historiques):
    indiceMoyen = np.mean(indices)
    pointsFinaux = [np.mean(list(historiques[k][i][-1] for k in range(nb))) for i in [0, 1]]

    print("Dans {} parties simulées, contre le total {} :".format(nb, total))
    for i in [0, 1]:
        print(" - le joueur {} ({.__name__:<11}) a gagné {:>5.2%} du temps, et a eu un score final moyen de {:>5g} points ...".format(i, joueurs[i], freqGain(indiceMoyen, i), pointsFinaux[i]))


# In[35]:


nb = 10000
joueurs = [unCoup, jusquauBout]
total = 1000
indices, historiques = desParties(nb, joueurs, total)
afficheResultatsDesParties(nb, joueurs, total, indices, historiques)


# In[36]:


nb = 10000
joueurs = [unCoup, jusquauBout]
total = 500
indices, historiques = desParties(nb, joueurs, total)
afficheResultatsDesParties(nb, joueurs, total, indices, historiques)


# In[37]:


nb = 10000
joueurs = [unCoup, jusquauBout]
total = 5000
indices, historiques = desParties(nb, joueurs, total)
afficheResultatsDesParties(nb, joueurs, total, indices, historiques)


# ----
# Affichons une première courbe qui montrera la supériorité d'une stratégie face à la plus peureuse, en fonction du total.

# In[99]:


def plotResultatsDesParties(nb, joueurs, totaux):
    N = len(totaux)
    indicesMoyens = []
    for total in totaux:
        indices, _ = desParties(nb, joueurs, total)
        indicesMoyens.append(np.mean(indices))
    plt.figure()
    plt.plot(totaux, indicesMoyens, 'ro')
    plt.xlabel("Objectif (points totaux à atteindre)")
    plt.ylabel("Taux de victoire de 1 face à 0")
    plt.title("Taux de victoire du joueur 1 ({.__name__}) face au joueur 0 ({.__name__}),\n pour {} parties simulees pour chaque total.".format(joueurs[1], joueurs[0], nb))
    plt.show()


# In[100]:


nb = 1000
joueurs = [unCoup, jusquauBout]
totaux = [50, 100, 150, 200, 250, 300, 350, 400, 450, 500]
plotResultatsDesParties(nb, joueurs, totaux)


# In[101]:


nb = 1000
joueurs = [unCoup, jusquauBout]
totalMax = 2000
totaux = list(range(50, totalMax + 50, 50))
plotResultatsDesParties(nb, joueurs, totaux)


# ----
# D'autres comparaisons, entre stratégies gourmandes.

# In[102]:


nb = 5000
joueurs = [auMoins100, auMoins200]
totalMax = 1000
totaux = list(range(50, totalMax + 50, 50))
plotResultatsDesParties(nb, joueurs, totaux)


# In[103]:


nb = 1000
joueurs = [auMoins100, jusquauBout]
totalMax = 2000
totaux = list(range(50, totalMax + 50, 100))
plotResultatsDesParties(nb, joueurs, totaux)


# In[104]:


nb = 1000
totalMax = 2000
totaux = list(range(50, totalMax + 50, 50))

joueurs = [unCoup, bernoulli(0.5)]
plotResultatsDesParties(nb, joueurs, totaux)


# In[105]:


joueurs = [unCoup, bernoulli(0.1)]
plotResultatsDesParties(nb, joueurs, totaux)


# In[106]:


joueurs = [unCoup, bernoulli(0.25)]
plotResultatsDesParties(nb, joueurs, totaux)


# In[107]:


joueurs = [unCoup, bernoulli(0.75)]
plotResultatsDesParties(nb, joueurs, totaux)


# In[108]:


joueurs = [unCoup, bernoulli(0.9)]
plotResultatsDesParties(nb, joueurs, totaux)


# ----
# ## Évaluation en *self-play*
# Plutôt que de faire jouer une stratégie face à une autre, et d'utiliser le *taux de victoire* comme une mesure de performance (ce que j'ai fait plus haut), on peut chercher à mesure un autre taux de victoire.
# 
# On peut laisser une stratégie jouer tout seule, et mesurer plutôt le *nombre de coup requis pour gagner*.

# In[19]:


def unePartieSeul(joueur, total=1000, debug=DEBUG):
    compte   = 0
    nbCoups  = 0
    nbLances = 0
    score   = [0]
    if debug: print("Simulation pour le joueur ({.__name__}), le total à atteindre est {} :".format(joueur, total))
    while compte < total:  # Tant que joueur n'a pas gagné
        nbCoups += 1
        if debug: print(" - Coup #{}, son compte est {} / {} ...".format(nbCoups, compte, total))
        accu, nbLance = unJeu(joueur, compte, total, debug)
        nbLances += nbLance
        if accu > 0:
            compte += accu
            score.append(compte)  # Historique
        if compte == total:
            if debug: print("- Le joueur ({.__name__}) a gagné en {} coups et {} lancés de dés !".format(joueur, nbCoups, nbLances))
            return score


# Testons ça avec la stratégie naïve `unCoup` :

# In[55]:


h = unePartieSeul(unCoup, 1000)
print("Partie gagnée en {} coups par le joueur ({.__name__}), avec le score {} ...".format(len(h), unCoup, h))


# ----
# Comme précédemment, on peut générer plusieurs simulations pour la même tâche, et obtenir ainsi une liste d'historiques de jeu.

# In[29]:


def desPartiesSeul(nb, joueur, total=1000, debug=False):
    historique = []
    for _ in range(nb):
        h = unePartieSeul(joueur, total=total, debug=debug)
        historique.append(h)
    return historique


# In[60]:


desPartiesSeul(4, unCoup)


# Ce qui nous intéresse est uniquement le nombre de coups qu'une certaine stratégie va devoir jouer avant de gagner :

# In[116]:


[len(l)-1 for l in desPartiesSeul(4, unCoup)]


# Avec un joli affichage et un calcul du nombre moyen de coups :

# In[117]:


def afficheResultatsDesPartiesSeul(nb, joueur, total, historique):
    nbCoupMoyens = np.mean([len(h) - 1 for h in historique])
    print("Dans {} parties simulées, contre le total {}, le joueur ({.__name__}) a gagné en moyenne en {} coups ...".format(nb, total, joueur, nbCoupMoyens))


# In[119]:


historique = desPartiesSeul(100, unCoup, 1000)
afficheResultatsDesPartiesSeul(100, unCoup, 1000, historique)


# Comme précédemment, on peut afficher un graphique montrant l'évolution de ce nombre moyen de coups, disons pour $1000$ parties simulées, en fonction du total à atteindre.
# La courbe obtenue devrait être croissante, mais difficile de prévoir davantage son comportement.

# In[120]:


def plotResultatsDesPartiesSeul(nb, joueur, totaux):
    N = len(totaux)
    nbCoupMoyens = []
    for total in totaux:
        historique = desPartiesSeul(nb, joueur, total)
        nbCoupMoyens.append(np.mean([len(h) - 1 for h in historique]))
    plt.figure()
    plt.plot(totaux, nbCoupMoyens, 'ro')
    plt.xlabel("Objectif (points totaux à atteindre)")
    plt.ylabel("Nombre moyen de coups joués avant de gagner")
    plt.title("Nombre moyen de coups requis par {.__name__}\n pour {} parties simulées pour chaque total.".format(joueur, nb))
    plt.show()


# ----
# On va utiliser les mêmes paramètres de simulation que précédemment : $1000$ simulations pour chaque total, et des totaux allant de $50$ à $2000$ par pas de $50$.

# In[121]:


nb = 1000
totalMax = 2000
totaux = list(range(50, totalMax + 50, 50))


# La courbe pour `unCoup` permet d'établir le comportement de la stratégie naïve, on pourra ensuite comparer les autres stratégies.

# In[122]:


plotResultatsDesPartiesSeul(nb, unCoup, totaux)


# > Tient, pour `unCoup`, la courbe est linéaire dans le total. C'est assez logique, vue la stratégie utilisée !
# > On marque à chaque coup, donc le nombre de coups moyens est juste le total divisé par le score moyen.
# > On se rappelle que le score moyen en un tirage est d'environ $96$ points (avec suite), et en effet $2000 / 91 \simeq 21$, ce qu'on lit sur la courbe.

# In[123]:


scoreMoyen = 96
total = 2000
total / scoreMoyen


# ----
# Pour `jusquauBout` :

# In[124]:


plotResultatsDesPartiesSeul(nb, jusquauBout, totaux)


# > On constate que cette stratégie `jusquauBout` gagne bien plus rapidement que la stratégie `unCoup` !

# ----
# Pour `auMoins200`, par exemple :

# In[125]:


plotResultatsDesPartiesSeul(nb, auMoins200, totaux)


# ----
# Pour `bernoulli(0.5)`, par exemple :

# In[126]:


plotResultatsDesPartiesSeul(nb, bernoulli(0.5), totaux)


# ----
# Pour `bernoulli(0.2)`, par exemple :

# In[127]:


plotResultatsDesPartiesSeul(nb, bernoulli(0.2), totaux)


# ----
# Pour `bernoulli(0.8)`, par exemple :

# In[128]:


plotResultatsDesPartiesSeul(nb, bernoulli(0.8), totaux)


# ----
# Ces comparaisons de différentes stratégies de Bernoulli permettent de conclure, comme on le présentait, que  la meilleure stratégie (parmi les quelques testées) est la stratégie `jusquauBout` !
# 
# Toutes les courbes ci dessus montrent un comportement (presque) linéaire du nombre moyen de coups requis pour gagner en fonction du total.
# 
# Ainsi, pour comparer différentes stratégies, on peut juste comparer leur nombre de coups moyen pour un certain total, disons $T = 2000$.

# In[138]:


def comparerStrategies(joueurs, nb=1000, total=2000):
    resultats = []
    for joueur in joueurs:
        historique = desPartiesSeul(nb, joueur, total)
        nbCoupMoyen = np.mean([len(h) - 1 for h in historique])
        resultats.append((nbCoupMoyen, joueur.__name__))
    # Trier les résultats permet de voir les meilleures stratégies en premier !
    return sorted(resultats)


# In[142]:


joueurs = [unCoup, jusquauBout]
comparerStrategies(joueurs, nb=nb, total=totalMax)


# On va comparer toutes les stratégies définies plus haut :

# In[146]:


joueurs = [unCoup, jusquauBout]
joueurs += [auMoins50, auMoins100, auMoins150, auMoins200, auMoins250, auMoins300, auMoins350, auMoins400, auMoins450, auMoins500, auMoins550, auMoins600, auMoins650, auMoins700, auMoins800, auMoins850, auMoins900, auMoins950, auMoins1000]
for p in range(0, 20 + 1):
    joueurs.append(bernoulli(p/20.))

# print([j.__name__ for j in joueurs])


# In[148]:


nb = 1000
totalMax = 2000
resultats = comparerStrategies(joueurs, nb=nb, total=totalMax)
print("Pour le total {} et {} simulations ...".format(totalMax, nb))
for (i, (n, j)) in enumerate(resultats):
    print("- La stratégie classée #{:2} / {} est {:<14}, avec un nombre moyen de coups = {:.3g} ...".format(i, len(joueurs), j, n))


# In[149]:


nb = 2000
totalMax = 3000
resultats = comparerStrategies(joueurs, nb=nb, total=totalMax)
print("Pour le total {} et {} simulations ...".format(totalMax, nb))
for (i, (n, j)) in enumerate(resultats):
    print("- La stratégie classée #{:2} / {} est {:<14}, avec un nombre moyen de coups = {:.3g} ...".format(i, len(joueurs), j, n))


# In[150]:


nb = 1000
totalMax = 5000
resultats = comparerStrategies(joueurs, nb=nb, total=totalMax)
print("Pour le total {} et {} simulations ...".format(totalMax, nb))
for (i, (n, j)) in enumerate(resultats):
    print("- La stratégie classée #{:2} / {} est {:<14}, avec un nombre moyen de coups = {:.3g} ...".format(i, len(joueurs), j, n))


# $\implies$ la stratégie la plus efficace est en effet `jusquauBout` !

# > Notons néanmoins que je n'ai testé que des stratégies très simples...
# > En particulier, celles considérées n'utilisent pas, dans leur prise de décision, le nombre de coups déja joué, ni le nombre de tirage courant.