#######################################################
#   Thème 5 : Simulations d'expériences aléatoires    #
#######################################################

## Importations
import random as rd
import matplotlib.pyplot as plt

## I) Jeu de pile ou face
# exercice 52

def pile_ou_face() :
    return rd.randint(0,1)

def frequence(f,N) :
    S = 0
    for _ in range(N) :
        S += f()
    return S/N

print(frequence(pile_ou_face,1000))
print(frequence(pile_ou_face,10000))

## II) Estimation de probabilités
# exercice 53

def tirage() :
    sac = [1]*5 + [0]*3
    return rd.choice(sac)

print(frequence(tirage,1000))
print(5/8)

## III) Variable de Bernoulli
# exercice 54

def Bernoulli(p) :
    return int(rd.random()<p)

def B(p) :  # fonction utile uniquement pour réutiliser la fonction 'frequence'
    def f():
        return Bernoulli(p)
    return f

L = [k/10 for k in range(11)]
for p in L :
    print(frequence(B(p),1000))
    print(p)
    print('______')

## IV) Schéma de Bernoulli
# exercice 55

def binome(n,p) :
    S = 0
    for _ in range(n) :
        S += Bernoulli(p)
    return S

# print(binome(10,0.2))

def proba(X,k,N) :
    compteur = 0
    for _ in range(N) :
        compteur += (X() == k)
    return compteur / N

def bi(n,p) :
    def f() :
        return binome(n,p)
    return f

def coeff_binomial(k,n) :
    P = 1
    a = n
    b = 1
    for _ in range(k) :
        P = a*P/b
        a -= 1
        b += 1
    return P

n = 10
p2 = 0.2
k = 3
print(proba(bi(n,p2),k,1000))
print(coeff_binomial(k,n)*p2**k*(1-p2)**(n-k))

## V) Jeu de dés
# exercice 56

def freq_de(N) :
    L=[0]*6
    for _ in range(N) :
        de = rd.randint(0,5)
        L[de] += 1
    for i in range(6) :
        L[i] = L[i]/N
    return L

def deux6() :
    compt = 0
    for _ in range(30) :
        de = rd.randint(1,6)
        if de == 6 :
            compt += 1
            if compt == 2 :
                return 1
        else :
            compt = 0
    return 0

print(frequence(deux6,1000))

## VI) Somme de deux dés
# exercice 57

def somme2des(N) :
    L = [0]*11
    for _ in range(N) :
        deuxdes = rd.randint(0,5)+rd.randint(0,5)
        L[deuxdes] += 1
    return L

def liste_to_freq(L) :
    S = sum(L)
    FL = []
    for k in range(len(L)) :
        FL.append(L[k]/S)
    return FL

L2des = somme2des(1000)
print('Fréquences obtenues en sommant 2 dés sur 1000 essais :')
print(liste_to_freq(L2des))

F2des = [(k-1)/36 for k in range(2,8)] + [(13-k)/36 for k in range(8,13)]
print('\nFréquences théoriques :')
print(F2des)

## VII) Temps d'attente du premier succès
# exercice 58

def geometrique(p) :
    rang = 1
    while rd.random() > p :
        rang += 1
    return rang

def geom(p) :
    def f() :
        return geometrique(p)
    return f

p3 = 0.3
print(frequence(geom(p3),1000))
print(1/p3)

## VIII) Temps d'attente du r-ème succès
# exercice 59

def attente(p,r) :
    rang = 0
    succes = 0
    while succes < r :
        rang += 1
        succes += (rd.random() < p)
    return rang

def att(p,r) :
    def f() :
        return attente(p,r)
    return f

r = 5
print(frequence(att(p3,r),1000))
print(r/p3)

## IX) Attente de pile-pile-face
# exercice 60

def attente_PPF() :
    L = [pile_ou_face() for _ in range(3)]
    rang = 3
    while L[-3]!=1 or L[-2]!=1 or L[-1]!=0 :
        rang += 1
        L.append(pile_ou_face())
    return rang

print(frequence(attente_PPF,1000))

## X) Longueur de série unicolore
# exercice 61

def unicolore() :
    c = pile_ou_face()
    long = 1
    while pile_ou_face() == c :
        long += 1
    return long

print(frequence(unicolore,1000))

## XI) Attente de succès consécutifs
# exercice 62

def attente_succes_consecutifs() :
    c = 0
    rang = 0
    while True : # "obtenir 2 succès consécutifs" est quasi-certain
        rang += 1
        lancer = pile_ou_face()
        if lancer == 1 :
            c += 1
            if c == 2 :
                return rang
        else :
            c = 0

print(frequence(attente_succes_consecutifs,1000))

## XII) Marche aléatoire
# exercice 63

def marche(N) :
    pos = 0
    L = [pos]
    for _ in range(N) :
        lancer = pile_ou_face()
        if lancer == 1 :
            pos += 1
        else :
            pos += -1
        L.append(pos)
    return L

def graphe(N) :
    L = marche(N)
    X = [k for k in range(N+1)]
    plt.plot(X,L)
    plt.show()

graphe(10000)
