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

Exercice 1

1. Simuler 1000 lancers d'un dé équilibré à six faces.
2. Pour cette simulation, déterminer le nombre de fois où le dé est tombé sur chacune des faces, et la fréquence associée.
3. Tracer le diagramme en bâton associé.

#1.
N=1000
A=rd.randint(1,7,N)

#2.
nb=np.zeros(6)
for i in range(6):
    nb[i]=np.sum(A==i+1)
print("Tableau des fréquences : ",nb/N)

Tableau des fréquences :  [0.181 0.145 0.157 0.187 0.168 0.162]

#Autre méthode :
nb=np.zeros(6)
for i in A:
    nb[i-1]+=1
print("Tableau des fréquences : ",nb/N)

Tableau des fréquences :  [0.181 0.145 0.157 0.187 0.168 0.162]

#3.
plt.hist(A,6)
plt.show()

Exercice 2

1. Ecrire une fonction qui simule le nombre de lancers nécessaires à l'obtention d'un six lors du lancer d'un dé équilibré, sans utiliser $\texttt{geom}$.
2. Faire 10000 simulations. Combien de lancers sont nécessaires en moyenne ?

#1.
def simu():
    n=1
    while (rd.rand()>1/6):
        n+=1
    return n

#2.
N=10000
A=[simu() for i in range(N)]
np.mean(A)

5.9388

# Autre méthode :
S=0
for i in range(N):
    S+=simu()
print("Nombre moyen de lancers nécessaires : ",S/N)

Nombre moyen de lancers nécessaires :  5.9824

Exercice 3

Une expérience consiste à effectuer 100 lancers d'une pièce telle que la probabilité d'obtenir pile vaut 0,3. On note $X$ la variable aléatoire égale au nombre de piles obtenus.

1. Créer une fonction $\texttt{X}$ prenant en entrée un entier $n$ qui réalise $n$ fois cette expérience et qui renvoie un tableau contenant les $n$ résultats.
2. Tracer le diagramme en bâton des résultats observés lors de la réalisation de 1000 expériences.

#1.
def X(n):
    res=np.zeros(n)
    for i in range(n):
        res[i]=rd.binomial(100,0.3)
    return(res)

#2.
resultat=X(1000)
plt.hist(resultat,10)
plt.show()

Exercice 4

Une puce se déplace sur un axe gradué en partant de l'origine. À chaque saut, elle se déplace d'une unité, de manière aléatoire et équiprobable vers la gauche ou vers la droite.

1. Écrire une fonction $\texttt{puce}$ d'argument $N$ et donnant la position de la puce au bout de $N$ sauts.
2. On effectue 1000 fois l'expérience durant laquelle la puce saute 200 fois. Tracer un diagramme en bâtons correspondant aux différentes positions de la puce pour $N = 200$ sauts.
3. On s'intéresse au numéro du saut donnant le premier retour à l'origine de la puce. Écrire une fonction $\texttt{PremRetour}$ sans argument et donnant le numéro de ce saut.
4. Donner une estimation du nombre moyen de sauts nécessaires pour un premier retour à l'origine. Effectuer plusieurs fois cette opération. Que remarque-t-on ?

#1.
def puce(N):
    n=0
    for i in range(N):
        if rd.rand()<1/2:
            n+=1
        else:
            n-=1
    return n

#2.
N=200
M=1000
positions=np.zeros(M)
for i in range(M):
    positions[i]=puce(N)
plt.hist(positions,10)
plt.show()

#3.
def PremRetour():
    n=puce(1)
    sauts=1
    while n!=0:
        if rd.rand()<1/2:
            n+=1
        else:
            n-=1
        sauts+=1
    return sauts

#4.
Nb=1000
S=0
for i in range(Nb):
    S+=PremRetour()
print("Estimation du nombre moyen de sauts nécessaires :",S/Nb)

Estimation du nombre moyen de sauts nécessaires : 1950.734

S=[PremRetour() for i in range(Nb)]
print("Estimation du nombre moyen de sauts nécessaires :",np.mean(S))

Estimation du nombre moyen de sauts nécessaires : 492.066

Exercice 5

1. Écrire une suite d'instructions pour approcher la probabilité que dans une classe de 42 élèves, deux élèves au moins soient nés le même jour, en faisant 1000 simulations. On ne comptera pas les années bissextiles.
2. Écrire une fonction $\texttt{anniv}$ d'argument $\texttt{n}$ et donnant la fréquence de l'événement dans une classe de $n$ élèves, pour 1000 simulations.
3. À partir de combien d'élèves cette fréquence est-elle supérieure à 0,5 ?

#1.
N=1000
NbMemeAnniv=0
for i in range(N):
    A=np.sort(rd.randint(1,366,42))
    MemeAnniv=False
    for j in range(41):
        if A[j]==A[j+1]:
            MemeAnniv=True
    if MemeAnniv:
        NbMemeAnniv+=1
print("Estimation de la probabilité : ",NbMemeAnniv/N)

Estimation de la probabilité :  0.909

#Autre méthode, sans trier :
N=1000
NbMemeAnniv=0
for i in range(N):
    A=rd.randint(1,366,42)
    MemeAnniv=False
    for j in range(42):
        l=np.where(A==A[j])
        if len(l[0])>1:
            MemeAnniv=True
    if MemeAnniv:
        NbMemeAnniv+=1
print("Estimation de la probabilité : ",NbMemeAnniv/N)

Estimation de la probabilité :  0.925

#Dernière version, plus maline :
N=1000
NbMemeAnniv=0
for i in range(N):
    A=rd.randint(1,366,42)
    NbMemeAnniv+=len(set(A))!=len(A)
print("Estimation de la probabilité : ",NbMemeAnniv/N)

Estimation de la probabilité :  0.913

#2.
def anniv(n):
    N=1000
    NbMemeAnniv=0
    for i in range(N):
        A=rd.randint(1,366,n)
        NbMemeAnniv+=len(set(A))!=len(A)
    return(NbMemeAnniv/N)

#3.
n=1
while anniv(n)<0.5:
    n+=1
print("Nombre d'élèves : ",n)

Nombre d'élèves :  23

def memeanniv(A):
    n=np.size(A)
    anniv=np.zeros(365)
    for i in range(n):
        anniv[A[i]]+=1
    return np.max(anniv)>1

A=rd.randint(0,365,42)
memeanniv(A)

False

Exercice 6

On considère une succession de $n$ lancers d'une pièce équilibrée, et on note $X$ la variable aléatoire égale au nombre de fois où l'on obtient deux tirages consécutifs identiques.

1. Écrire une fonction d'argument $n$ qui réalise la variable aléatoire $X$.
2. Faire 1000 simulations, et tracer un histogramme des valeurs de $X$ pour $n=30$.
3. Calculer une estimation de $\mathbb{E}(X)$ et de $\mathbb{V}(X)$.

#1.
def f(n):
    tirages=rd.randint(0,2,n)
    N=0
    for i in range(n-1):
        if tirages[i]==tirages[i+1]:
            N+=1
    return N

#2.
N=1000
n=30
val=np.zeros(N)
for i in range(N):
    val[i]=f(n)
plt.hist(val,np.arange(0,n+1))
plt.show()

#3.
EX=np.mean(val)
print("Estimation de E(X) : ", EX)
VX=np.mean((val-EX)**2)
print("Estimation de V(X) : ", VX)

Estimation de E(X) :  14.502
Estimation de V(X) :  7.627996

Exercice 7

Une urne contient $r$ boules rouges et $b$ boules bleues. On tire successivement et sans remise $n$ boules de l'urne, avec $1 \leqslant n \leqslant r+b$, et on note $X$ le nombre de boules rouges obtenues.

1. Écrire une fonction $\texttt{urne}$ qui a pour arguments $r$, $b$ et $n$, et qui réalise la variable aléatoire $X$.
2. On se place dans la situation où $(r,b,n) = (7,13,9)$. Estimer l'espérance et la variance de $X$.

#1.
def urne(r,b,n):
    R, B = r, b
    N=0
    for i in range(n):
        if rd.rand()<R/(R+B):
            N+=1
            R-=1
        else:
            B-=1
    return(N)

#Version récursive :
def urne(r,b,n):
    if n==0:
        return 0
    else:
        if rd.rand()<r/(r+b):
            return 1+urne(r-1,b,n-1)
        else:
            return urne(r,b-1,n-1)

#2.
r, b, n = 7, 13, 9
N=1000
val=np.array([urne(r,b,n) for i in range(N)])
EX=np.mean(val)
print("Estimation de E(X) :",EX)
print("Espérance exacte :",n*r/(r+b))
VX=np.var(val)
print("Estimation de V(X) :",VX)
print("Variance exacte :",n*r*b/((r+b)**2)*(r+b-n)/(r+b-1))

Estimation de E(X) : 3.154
Espérance exacte : 3.15
Estimation de V(X) : 1.2642840000000004
Variance exacte : 1.1853947368421052

Exercice 8

On lance indéfiniment une pièce telle que la probabilité d'obtenir pile vaut $p \in ]0,1[$. On note $L_1$ la longueur de la première série, et $L_2$ la longueur de la deuxième. Par exemple, si les lancers ont donné $PPPFFFFPFF$, alors $L_1 = 3$ et $L_2 = 4$.

1. Écrire une fonction $\texttt{series}$ d'argument $p$, qui donne les longueurs des deux premières séries.
2. Estimer les espérances de $L_1$ et $L_2$.

#1.
def series(p):
    res1=rd.binomial(1,p)
    L1=1
    while(rd.binomial(1,p)==res1):
        L1+=1
    L2=1
    while(rd.binomial(1,p)==1-res1):
        L2+=1
    return(L1,L2)

#2.
p=0.21
N=10000
X=np.array([series(p)[0] for i in range(N)])
Y=np.array([series(p)[1] for i in range(N)])
print('Estimation de E(L1) :',np.mean(X))
print('Estimation de E(L2) :',np.mean(Y))

Estimation de E(L1) : 3.9906
Estimation de E(L2) : 1.9872

Exercice 9

On lance indéfiniment une pièce telle que la probabilité d'obtenir pile vaut $p \in ]0,1[$.

1. Écrire une fonction $\texttt{attente}$ d'arguments $p$ et $k$, qui donne le nombre de lancers nécessaires pour obtenir le $k$-ème pile.
2. On réalise cette expérience 10000 fois. Estimer le nombre moyen de lancers nécessaires pour obtenir le $k$-ème pile.

#1.
def attente(p,k):
    S=0 #Nombre de piles obtenus
    n=0 #Nombre de lancers
    while(S<k):
        if rd.rand()<p:
            S+=1
        n+=1
    return(n)

#2.
p=0.4
k=10
N=10000
Res=np.array([attente(p,k) for i in range(N)])
print('Estimation du nombre moyen de lancers :',np.mean(Res))
print('Valeur exacte :',k/p)

Estimation du nombre moyen de lancers : 25.0443
Valeur exacte : 25.0

Exercice 10

On lance deux dés équilibrés à six faces.

1. Écrire une fonction $\texttt{des}$ d'argument $n$, et renvoyant une matrice à deux colonnes simulant les réalisations de $n$ lancers de ces deux dés.
2. Construire le tableau des sommes de ces deux dés pour chacun des $n$ lancers.
3. Construire et afficher le tableau des fréquences observées de ces sommes.
4. Déterminer et afficher la somme la plus fréquente.

#1.
def des(n):
    return rd.randint(1,7,[n,2])

#2.
n=100
Res=des(n)
S=np.sum(Res,axis=1) #Tableau des sommes

#3.
Val=np.zeros(11) #Tableau des effectifs pour chaque valeur de la somme
for i in range(n):
    Val[S[i]-2]+=1
Freq=Val/n
print(Freq)

[0.03 0.07 0.06 0.18 0.15 0.12 0.12 0.12 0.07 0.06 0.02]

#4.
print('Somme la plus fréquente :',np.where(Val==max(Val))[0][0]+2)

Somme la plus fréquente : 5

#4. Autre méthode
Val=np.zeros((2,11)) # Tableau des effectifs pour chaque valeur de la somme en première ligne
Val[0,:]=np.arange(2,13)
for i in range(n):
    Val[1,S[i]-2]+=1
print('Tableau des valeurs :')
print(Val)
max=0
for k in range(11):
    if Val[1,k]>max:
        max=Val[1,k]
        s=k
print('Somme la plus fréquente :',Val[0,s])

Tableau des valeurs :
[[ 2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12.]
 [ 3.  7.  6. 18. 15. 12. 12. 12.  7.  6.  2.]]
Somme la plus fréquente : 5.0

Exercice 11

1. Soit $X$ une variable aléatoire suivant la loi binomiale de paramètres $n$ et $p$. Créer une fonction $\texttt{simubin}$ de paramètres $n$, $p$ et $k$, simulant la probabilité $P(X=k)$.
2. Soit $Y$ une variable aléatoire suivant la loi de Poisson de paramètre $\lambda$. Créer une fonction $\texttt{simupoi}$ de paramètres $\lambda$ et $k$, simulant la probabilité $P(Y=k)$.
3. Créer une fonction $\texttt{compa}$ d'arguments $n$ et $p$, donnant en sortie une matrice avec 2 lignes et $n+1$ colonnes : la première ligne donne les $P(X=k)$ pour $k \in [\![0,n]\!]$, et la seconde les $P(Y=k)$ pour $k \in [\![0,n]\!]$, où $\lambda = np$.
4. Tester la fonction $\texttt{compa}$ pour $(n,p) \in \{(30, 0.4), (30,0.2), (30,0.1), (30,0.05)\}$. Penser à faire des tracés. Que conclure ?
5. Tester la fonction $\texttt{compa}$ pour $(n,p) \in \{(10,0.1), (20,0.1), (30,0.1), (50,0.1)\}$. Penser à faire des tracés. Que conclure ?

#1.
def simubin(n,p,k):
    N=10000
    Bin=rd.binomial(n,p,N)
    nb=0 # Nombre de fois où on obtient k
    for i in range(N):
        if Bin[i]==k:
            nb+=1
    return(nb/N)

# Autre méthode :
def simubin(n,p,k):
    N=10000
    Bin=rd.binomial(n,p,N)
    return(np.sum(Bin==k)/N)

#2.
def simupoi(lamb,k):
    N=10000
    Poi=rd.poisson(lamb,N)
    nb=0 # Nombre de fois où on obtient k
    for i in range(N):
        if Poi[i]==k:
            nb+=1
    return(nb/N)

#3.
def compa(n,p):
    P=np.zeros((2,n+1))
    for k in range(n+1):
        P[:,k]=np.array([simubin(n,p,k),simupoi(n*p,k)])
    return(P)

#4.
n=30
for p in [0.4,0.2,0.1,0.05]:
    LX=np.arange(0,n+1)
    print('n =',n,' p =',p)
    plt.plot(LX,abs(compa(n,p)[0,:]))
    plt.plot(LX,abs(compa(n,p)[1,:]))
    plt.show()

n = 30  p = 0.4

n = 30  p = 0.2

n = 30  p = 0.1

n = 30  p = 0.05

#5.
p=0.1
for n in [10,20,30,50]:
    LX=np.arange(0,n+1)
    print('n =',n,' p =',p)
    plt.plot(LX,abs(compa(n,p)[0,:]))
    plt.plot(LX,abs(compa(n,p)[1,:]))
    plt.show()

n = 10  p = 0.1

n = 20  p = 0.1

n = 30  p = 0.1

n = 50  p = 0.1