# Effectuer la saisie pour créer la liste abs_bille



#Exécuter cette cellule pour mettre la fonction Visualisation_Planche_Galton en mémoire

from copy import deepcopy
import matplotlib.pyplot as plt
from matplotlib import animation, rc
from IPython.display import HTML

def Visualisation_Planche_Galton(Positions_billes, attente=3, Temps_total=5000, hauteur=8, resolution=80):
    '''
    Fonction permettant la visualisation d'une chute de billes sur la planche de Galton
    Liste_billes: chaque élément est la liste des abscisses d'une bille (list)
    attente: attente entre chaque bille lachée: écart des ordonnées entre deux billes successives (int) 
    Temps_total: Durée totale de visionnage en ms (int) 
    hauteur: Hauteur du graphique en pouces (float)
    resolution: résolution en dpi (int)
    '''
    #Duplication profonde de la liste des listes des abscisses
    Liste_billes=deepcopy(Positions_billes)
    
    N=max([len(b) for b in Liste_billes])-1 #hauteur de la planche (Attention: les listes ont normalement la même taille)
    M=len(Liste_billes)//2+1 #hauteur du réceptacle pour les billes
            
    #Réglages de la fenêtre d'affichage
    largeur=2*N*hauteur/(N+M+0.25) ; borne_x=N+1/2
    plt.figure(num=0, figsize=(largeur,hauteur), dpi=resolution) ; fig,ax = plt.subplots(num=0)    
    ax.set_xlim(( -borne_x,borne_x)) ; ax.set_ylim((-M-0.25, N)) ; ax.xaxis.set_ticks(range(-N,N+1))
    plt.tick_params(axis = 'x', labelsize = 8) ; plt.yticks([], [])    
    
    #taille des billes
    taille_bille=242//(N+M+0.25)   
    
    #représentation de la planche de Galton
    list_x=[2*k-(L-1) for L in range(N+1) for k in range(L)]
    list_y=[N-L for L in range(N+1) for k in range(L)]
    Trace_Galton,= ax.plot(list_x,list_y, ls="none", marker=".",color="black")
    
    #Objet pour la représentation des billes descendantes   
    Trace_billes,= ax.plot([], [], ls="none", marker="o",color="blue", markersize=taille_bille)  
     
    #Objet pour la représentation des billes accumulées dans le réceptacle     
    Trace_point_acc, = ax.plot([], [], ls="none", marker="o",color="blue", markersize=taille_bille)
    
    #Liste des effectifs de billes accumulées         
    accumulation=[0 for x in range(-N,N+1)]
    
    #Initialisation des positions des billes
    b_x=[None for p in range(len(Liste_billes))] # liste des abscisses des billes à placer           
    b_y=[None for p in range(len(Liste_billes))] # liste des ordonnées des billes à placer
    
    def init():
        """
        Fonction initialisant l'animation
        """
        return (Trace_Galton,Trace_billes,Trace_point_acc,)   
    
    def animate(i):     
        """
        Fonction définissant la i ème scène de l'animation
        """
        #gestion des billes en descente
        for p in range(len(Liste_billes)): #pour chaque bille
            if Liste_billes[p] and i>=attente*p:#s'il reste des positions à traiter et qu'on a lâché la bille
                if len(Liste_billes[p])>1: #si ce n'est pas la dernière position
                    b_x[p],b_y[p] = Liste_billes[p].pop(0),N-i+attente*p #on place la bille à sa position et on efface cette position
                elif -M+0.5*(accumulation[N+int(Liste_billes[p][0])]-1)<N-i+attente*p: #sinon si on n'a pas atteint la hauteur accumulée
                    b_x[p],b_y[p] = Liste_billes[p][0],N-i+attente*p #on place la bille à sa nouvelle position (descente verticale)
                else: #sinon
                    accumulation[N+int(Liste_billes[p].pop(0))]+=1 #on compte la bille comme accumulée 
                    b_x[p],b_y[p] = None,None #et on supprime la position                  
        
        #Représentation des billes en descente
        Trace_billes.set_data(b_x,b_y)  
        
        #Représentation des billes accumulées dans les réceptacles       
        l_x,l_y = [k for k in range(-N,N+1) for y in range(accumulation[N+k])],[-M+0.5*y for k in range(-N,N+1) for y in range(accumulation[N+k])]
        Trace_point_acc.set_data(l_x,l_y)    
                
        return (Trace_Galton,Trace_billes,Trace_point_acc,)
      
    #Création de l'animation
    Nb_images=attente*len(Liste_billes)+N+M
    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=Nb_images, interval=Temps_total/Nb_images, blit=False, repeat=False)   
    
    return HTML(anim.to_jshtml())


#Exécuter cette cellule pour observer la trajectoire de la bille correspondante à abs_bille

Visualisation_Planche_Galton( [abs_bille] )


#Ecrire ici la fonction suiv d'argument x
from random import random





def trajet():
    '''
    Compléter ici
    la description
    de la fonction
    '''
    x=0
    L=[x]
    for k in range(5):
        x=suiv(x)
        L.append(x)
    return L 

#Créer ici une liste abs_bille à l'aide de la fonction trajet précédente



#Valider cette cellule pour voir la liste abs_bille qui a été générée
abs_bille


#Exécuter cette cellule pour observer le trajet de la bille

Visualisation_Planche_Galton( [abs_bille] )


#Valider la cellule

#Création d'une liste de trajets de 50 billes
liste_trajets = [ trajet() for b in range(50) ]

#Affichage des trajets
liste_trajets

#Création de l'animation sur la planche de Galton
Visualisation_Planche_Galton( liste_trajets )

#Ajouter l'argument N à la fonction trajet

def trajet():
    '''
    (reprendre et adapter la description vue à la question 1.4.a.)
    '''
    x=0
    L=[x]
    for k in range(5):
        x=suiv(x)
        L.append(x)
    return L 

#Créer liste_trajets correspondant à 100 trajets de billes sur une planche de Galton à 10 étages
liste_trajets = [ trajet(10) for b in range(100) ]

#Valider cette cellule pour afficher les listes de trajets
liste_trajets

#Création de l'animation sur la planche de Galton
Visualisation_Planche_Galton( liste_trajets )

liste_trajets[0] #permet d'obtenir la liste des abscisses de la bille de rang 0

liste_trajets[0][-1] #permet d'obtenir l'abscisse finale de la bille de rang 0

liste_trajets[1] #permet d'obtenir la liste des abscisses de la bille de rang 1

liste_trajets[1][-1] #permet d'obtenir l'abscisse finale de la bille de rang 1

# Ecrire la fonction decompte

def decompte(liste_trajets):
    compteur=0
    for k in range(len(liste_trajets)):
        if liste_trajets[k][-1]==4:
            compteur=compteur+1
    return compteur

#test avec la liste précédemment générée
decompte(liste_trajets)

# Ecrire la fonction decompte modifiée

def decompte(liste_trajets,a):
    compteur=0
    for k in range(len(liste_trajets)):
        if liste_trajets[k][-1]==a:
            compteur=compteur+1
    return compteur


# Ecrire la fonction frequence

def frequence(liste_trajets,a):
    return decompte(liste_trajets,a)/len(liste_trajets)

# Effectuer l'appel à la fonction frequence
f=frequence(liste_trajets,4)
f

from math import factorial

def combinaison(n,k): 
    "fonction qui calcule le coefficient binomial de paramètres n et k"
    return factorial(n)//(factorial(k)*factorial(n-k))

# Effectuer une saisie pour le calcul de la probabiltié


# Effectuer une saisie pour la comparaison des deux valeurs