Le code complet du projet

## BOITOUZET Emilien
## CMI-INFO
## La ruine d'un joueur


import random
import matplotlib.pyplot as plt
import numpy as np



# simulation d'une partie de jeu équilibré 
def ruine(a,b,p):
    """simulation d'une soirée au casino (jeu de la roulette)

            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
            en sortie : g -> 0 si ruiné sinon 1
                        s le tableau de l'évolution de l'argent du joueur
                        t le temps de la partie """
    c = a   
    s = [a]
    while c != 0 and c < a + b :
        res = random.uniform(0,1) # renvoie un nombre entre 0 et 1
        if res <= p: #Joueur à gagner cette mise
            c = c + 1
        else :       #Joueur à perdu cette mise
            c = c - 1
        s = s + [c]
    if c == 0 :         # Joueur ruiné
        g = 0
    elif c == a + b :   # Joueur a gagné
        g =  1
    t = len(s)          #Temps de jeu
    return s, g, t

def ruineG(a,b,p):
    """fonction qui trace le graphe de l'évolution de la richesse du joueur
            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
            en sortie : le graphe """
    
    casino = ruine(a,b,p)
    print(casino)
    plt.clf()                               #pas de graphe antérieur sur la figure
    x = [i for i in range(len(casino[0]))]  #coordonées en x
    y = casino[0]                           #coordonnées en y

    plt.plot(x,y)                           #dessin du graphe
    plt.title("simulation d'une soirée au casino")#titre du graphe
    plt.xlabel("n° de mise")                #titre de l'axe des abscisses
    plt.ylabel("richesse du joueur")        #titre de l'axe des ordonnées

    plt.show()                              #afficher le graphe
    plt.close








def est_ruine(a,b,p,nb):
    """Fonction qui compte le nombre de fois ou le joueur est ruiné

            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
                        nb le nombre de soirée
            en sortie : une probabilité, le nombre de fois ou le joueur repart ruiné"""
    i = 0
    res = 0
    while nb > i :
        
        if ruine(a,b,p)[1] != 1:
            res = res + 1
        i = i + 1
    return res / nb

def temps_moy(a,b,p,nb):
    """Fonction qui calcul le temps moyen d'une soirée au casino

        en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
                        nb le nombre de soirée
        en sortie : un entier, le temps moyen passé au casino"""
    d = 0
    c = 0 
    for i in range (nb):
        c = ruine(a,b,p)[2]
        
        d = d + c
       
    res = d / nb
    return res

# Partie théorique

def theorie(a,b,p):
    """Fonction qui nous donne les résultats théoriques

            en entrée : a, la richesse initiale du joueur
                        b, la somme que le joueur veut atteindre
                        p, la probabilité de gagner
            en sortie : des flottants """
    if p == 1/2 :               #Probabilité de gagner
        pRuine = b /(a + b)     #Proba théorique de perdre
        pGagne = a / (a + b)    #Proba théorique de gagner
        eT = a*b                #Estimation théorique du temps de jeu
        res = (pRuine, pGagne, eT)
    else :
        r = (1 - p) / p
        pRuine = (r**(a+b)-r**a)/(r**(a+b)-1)
        pGagne = (r**a-1)/(r**(a+b)-1)
        eT = 1/(2*p-1)*((((a+b)*(1-r**a))/(1-r**(a+b)))-a)
        res = (pRuine, pGagne, eT)
    
    return res

def graphe_pRuine (a,b,p,nb):
    """Fonction qui trace le graphe de la probabilité d'être ruiné et
    la droite de la valeur théorique"""
    pas = 1
    res2 = []
    i = 1
    while i < nb+1 :
        res2 = res2 + [est_ruine(a,b,p,i)]
        i = i + pas
        
    plt.clf()
    x = [i for i in range(1,nb+1,pas)]
    y1 = res2
    y2 = [theorie(a,b,p)[0]]*len(x)
    plt.plot(x,y1)
    plt.plot(x,y2)
    plt.title("Évolution de la probabilité d'être ruiné")
    plt.xlabel("n° de la partie")                
    plt.ylabel("probabilité d'être ruiné")
    plt.show()

def graphe_pGagne (a,b,p,nb):
    """Fonction qui trace le graphe de la probabilité de gagné et
    la droite de la valeur théorique"""
    pas = 1
    res = []
    i = 1
    while i < nb+1 :
        res = res + [1-(est_ruine(a,b,p,i))]
        i = i + pas

    plt.clf()
    x = [i for i in range(1,nb+1,pas)]
    y1 = res
    y2 = [theorie(a,b,p)[1]]*len(x)
    plt.plot(x,y1)
    plt.plot(x,y2)
    plt.title("Évolution de la probabilité de gagner")
    plt.xlabel("n° de la partie")                
    plt.ylabel("probabilité de gagner")
    plt.show()
    
def graphe_eT(a,b,p,nb):
    """fonction qui trace la courbe représentative du temps de jeux et le
    temps théorique du temps de jeux"""
    pas = 1
    res = []
    i = 1
    
    while i < nb+1 :
        res = res + [temps_moy(a,b,p,i)]
        i = i + pas

    plt.clf()
    x = [i for i in range(1,nb+1,pas)]
    y1 = res
    y2 = [theorie(a,b,p)[2]]*len(x)
    plt.plot(x,y1)
    plt.plot(x,y2)
    plt.title("Évolution du temps de jeu")
    plt.xlabel("n° de la partie")                
    plt.ylabel("Temps de jeu")
    plt.show()
   
def graphe (a,b,p,nb):
    """fonction qui trace tous les graphes ci-dessus"""
    graphe_pRuine(a,b,p,nb)
    graphe_pGagne(a,b,p,nb)
    graphe_eT(a,b,p,nb)