Algorithmes et Suites en Python

Correction Question 1 :

En exécutant la fonction Devine(n) pour $n=5, 10, 20$, on observe que les valeurs retournées augmentent avec $n$. Plus $n$ est grand, plus la valeur retournée est élevée. Cela suggère que la suite définie par cet algorithme pourrait être croissante et potentiellement diverger vers l'infini.

Correction Question 2 :

Voici la fonction modifiée pour afficher les étapes intermédiaires :

def Devine_modifiee(n):
    u = 1
    print("u_0 = ", u) # Affichage du terme initial
    for k in range(n):
        u = (1 + 1/(k + 1)) * u
        print("k = ", k, ", u = ", u) # Affichage de k et u à chaque itération
    return u
                            

Correction Question 3 :

En testant avec des valeurs de $n$ de plus en plus grandes (par exemple, $n=100, 1000$), on observe que les valeurs de la suite continuent d'augmenter sansVisiblement se stabiliser. Cela renforce la conjecture que la suite $(u_n)$ diverge vers l'infini. Il n'y a pas de limite finie apparente pour cette suite.

Correction Question 1 :

l est indispensable d'initialiser 𝑈 à 1/2 . et on initialise la liste avec 𝑢 car on calcule dans la boucle les termes successifs. Dans la boucle, on calcule les 𝑛 termes suivants de la suite et on les place dans la liste grâce à append. Il faut donc faire 𝑛 calculs donc 𝑖 décrit range(0 , n)

def SuiteU_n(n):
    u = 1/2
    for i in range(n):
        u = 2 * u / (1 + u)
    return u
                            

Correction Question 2 :

Voici les 10 premiers termes de la suite calculés avec l'algorithme :

for i in range(10):
    termes = SuiteU(i)
    print("u_", i, " = ", termes[-1])
                            

Les valeurs affichées sont : u_0 = 0.5, u_1 = 0.666..., u_2 = 0.8, u_3 = 0.888..., u_4 = 0.941..., u_5 = 0.969..., u_6 = 0.984..., u_7 = 0.992..., u_8 = 0.996..., u_9 = 0.998...

On conjecture que la suite $(u_n)$ semble converger vers 1.

Correction Question 3 :

Voici la fonction modifiée pour retourner la liste des termes :

def SuiteU_liste(n):
    u = 1/2
    L = [u]
    for i in range (n):
        u = 2 * u / (1 + u)
        L.append(u)
    return L
                            

Correction Question 4 :

Testons l'algorithme modifié pour calculer les 5 premiers termes :

print(SuiteU_liste(5))
                            

L'algorithme retourne la liste : [0.5, 0.6666666666666666, 0.8, 0.8888888888888888, 0.9411764705882353, 0.9696969696969697], ce qui correspond aux premiers termes observés précédemment et confirme la cohérence de notre algorithme modifié.

Correction Question 1 :

Calculons les premières valeurs de la suite à la main :
$u_0 = 20$
$u_1 = 0.8 \times 20 + 50 = 16 + 50 = 66$
$u_2 = 0.8 \times 66 + 50 = 52.8 + 50 = 102.8$
$u_3 = 0.8 \times 102.8 + 50 = 82.24 + 50 = 132.24$

Les premières valeurs de la suite sont donc : $u_0 = 20$, $u_1 = 66$, $u_2 = 102.8$, $u_3 = 132.24$.

Correction Question 2 :

En calculant les sommes $S_5$, $S_{10}$ et $S_{15}$ avec la fonction Somme(u0, n), on observe que la somme augmente avec $n$. Cependant, l'augmentation devient de plus en plus faible à mesure que $n$ grandit, suggérant une possible convergence de la somme ou un ralentissement de sa croissance.

print("S_5 = ", Somme(20, 5))
print("S_10 = ", Somme(20, 10))
print("S_15 = ", Somme(20, 15))
                            

Correction Question 3 :

Voici la fonction Somme(u0, n) modifiée pour afficher les valeurs intermédiaires :

def Somme_modifiee(u0, n):
    U = u0
    S = 0
    for i in range(n + 1):
        S = S + U
        print("i = ", i, ", U = ", U, ", S = ", S) # Affichage de U et S à chaque itération
        U = 0.8 * U + 50
    return S
                            

En exécutant Somme_modifiee(u0, n), on voit clairement comment chaque terme de la suite $(u_n)$ est ajouté à la somme cumulative $S$. On observe que $U$ augmente puis se stabilise, tandis que $S$ continue d'augmenter mais de plus en plus lentement.

Correction Question 4 :

Utilisons la fonction Proche(e) pour différentes précisions :

print("Seuil pour e=0.1 : N = ", Proche(0.1))
print("Seuil pour e=0.01 : N = ", Proche(0.01))
print("Seuil pour e=0.001 : N = ", Proche(0.001))
                            

On observe que lorsque la précision $e$ augmente (c'est-à-dire que le seuil devient plus petit), l'indice $N$ augmente également. Cela est logique car il faut plus d'itérations pour que la suite $U_n$ se rapproche de plus en plus de la valeur cible (3) avec une meilleure précision. Plus la précision demandée est grande, plus il faut attendre que la suite se stabilise près de sa limite.

Correction Question 1 :

Calcul des 10 premiers termes de la suite de Syracuse en partant de $u_0 = 7$ :
$u_0 = 7$ (impair)
$u_1 = 3 \times 7 + 1 = 22$ (pair)
$u_2 = 22 / 2 = 11$ (impair)
$u_3 = 3 \times 11 + 1 = 34$ (pair)
$u_4 = 34 / 2 = 17$ (impair)
$u_5 = 3 \times 17 + 1 = 52$ (pair)
$u_6 = 52 / 2 = 26$ (pair)
$u_7 = 26 / 2 = 13$ (impair)
$u_8 = 3 \times 13 + 1 = 40$ (pair)
$u_9 = 40 / 2 = 20$ (pair)

Correction Question 2 :

Utilisons la fonction Syracuse(debut) pour vérifier nos calculs et afficher la suite complète :

print("Syracuse(7) = ", Syracuse(7))
                            

L'algorithme retourne : (17, [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]), ce qui confirme nos calculs manuels pour les 10 premiers termes et affiche la suite complète jusqu'à 1.

Correction Question 3 :

Voici la fonction modifiée pour afficher la règle appliquée à chaque étape :

def Syracuse_modifiee(debut):
    u = debut
    L = [u]
    n = 1
    print("u_0 = ", u) # Affichage du terme initial
    while u > 1:
        if u != 2 * (u//2):
            u = 3 * u + 1
            regle = "impair"
        else:
            u = u // 2
            regle = "pair"
        L.append(u)
        n = n + 1
        print("u_{0} = {1} (règle: {2})".format(n - 1, u, regle)) # Affichage de u et de la règle appliquée
    return n, L
                            

Correction Question 4 :

Testons avec des valeurs de départ plus élevées :

print("Syracuse(27) = ", Syracuse(27))
print("Syracuse(127) = ", Syracuse(127))
print("Syracuse(256) = ", Syracuse(256))
                            

- Pour debut=27, le temps de vol est très long (112) et l'altitude maximale très élevée (9232).
- Pour debut=127, le temps de vol est de 46 et l'altitude maximale est 4372.
- Pour debut=256, le temps de vol est court (9) et l'altitude maximale est basse (256).

Ces résultats montrent la grande variabilité du comportement de la suite de Syracuse. Le temps de vol et l'altitude maximale ne sont pas directement proportionnels à la valeur de départ et peuvent varier de manière imprévisible.

Correction Question 1 :

Pour $u_0 = 15$, la fonction Syracuse(15) affiche la liste des termes : (18, [15, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]).

En observant ces valeurs, on remarque que la suite oscille de manière irrégulière, alternant entre des pics et des chutes, sans qu'une valeur moyenne évidente ne se dégage immédiatement.

Correction Question 2 :

Pour calculer la moyenne des premiers termes, nous devons sommer les termes et diviser par le nombre de termes. Voici une fonction possible :

def Syracuse_Moyenne(debut, nombre_termes):
    u = debut
    L = [u]
    somme = u # Initialisation de la somme avec le premier terme
    for i in range(nombre_termes - 1): # On itère pour les termes suivants
        if u % 2 == 0: # Test de parité plus simple avec l'opérateur modulo
            u = u // 2
        else:
            u = 3 * u + 1
        L.append(u)
        somme = somme + u # Ajout du nouveau terme à la somme
    moyenne = somme / nombre_termes
    return moyenne
                            

Correction Question 3 :

Testons la fonction Syracuse_Moyenne pour différentes valeurs de nombre_termes :

print("Moyenne des 10 premiers termes : {}".format(Syracuse_Moyenne(15, 10)))
print("Moyenne des 100 premiers termes : {}".format(Syracuse_Moyenne(15, 100)))
print("Moyenne des 1000 premiers termes : {}".format(Syracuse_Moyenne(15, 1000)))
                            

Les résultats montrent que la moyenne varie, mais semble se stabiliser autour d'une certaine valeur lorsque nombre_termes augmente. Cela suggère que, malgré les oscillations de la suite de Syracuse, la moyenne de ses premiers termes pourrait tendre vers une valeur spécifique.

Correction Question 4 :

Pour visualiser l'évolution de la moyenne cumulée, nous pouvons modifier la fonction comme suit :

def Syracuse_Moyenne_Cumulative(debut, nombre_termes):
    u = debut
    L = [u]
    somme_cumulative = 0
    for i in range(nombre_termes):
        if u % 2 == 0:
            u = u // 2
        else:
            u = 3 * u + 1
        L.append(u)
        somme_cumulative = somme_cumulative + u
        moyenne_cumulative = somme_cumulative / (i + 2) # i+2 car on inclut u_0 et le terme courant
        print("Terme u_{0} = {1}, Moyenne cumulative après {2} termes : {3}".format(i + 1, u, i + 2, moyenne_cumulative))
    return moyenne_cumulative
                            

En exécutant Syracuse_Moyenne_Cumulative(15, 20), on observe comment la moyenne cumulée évolue à chaque étape. Cela peut aider à mieux comprendre si la moyenne tend à se stabiliser ou continue de varier de manière significative. Dans le cas de la suite de Syracuse, bien qu'il n'y ait pas de convergence prouvée vers une valeur moyenne, cette exploration numérique donne une intuition de son comportement statistique.

Correction Question 1 :

En exécutant dicho_croiss(1, 2, 0.1), la fonction retourne l'intervalle [1.375 ; 1.4375]. Pour vérifier, on peut calculer $f(1.375) \approx -0.159$ et $f(1.4375) \approx 0.154$. Puisque $f(1.375) < 0$ et $f(1.4375) > 0$, et que la fonction $f$ est continue et croissante sur $[1, 2]$, le théorème des valeurs intermédiaires nous assure qu'il existe bien un zéro de $f$ dans cet intervalle.

Correction Question 2 :

Voici la fonction modifiée pour afficher le nombre d'itérations :

def dicho_croiss_iterations(a, b, p):
    iterations = 0
    while b - a > p:
        m = (a + b) / 2
        if f(m) == 0:
            break
        elif f(m) < 0:
            a = m
        else:
            b = m
        iterations = iterations + 1 # Incrementation modifiée
    if f(m) == 0:
        print(m,"est la solution recherchée")
    else:
        print("[" ,a, ";" ,b, "]")
    print("Nombre d'iterations : {}".format(iterations))
                            

En testant, on observe que le nombre d'itérations reste relativement faible même pour une précision élevée, ce qui illustre l'efficacité de la dichotomie.

Correction Question 3 :

Voici une fonction dicho_general qui prend en compte le sens de variation de la fonction :

def dicho_general(f, a, b, p, croissance):
    while b - a > p:
        m = (a + b) / 2
        if f(m) == 0:
            break
        elif (f(m) < 0 and croissance) or (f(m) > 0 and not croissance):
            a = m
        else:
            b = m
    if f(m) == 0:
        print(m,"est la solution recherchée")
    else:
        print("Intervalle solution = [", a, ";", b, "]")
                            

Correction Question 4 :

Pour tester la fonction dicho_general avec une fonction décroissante, on utilise l'intervalle $[-1, 0]$ où $f(x) = x^3 + 2x^2 - 4x - 1$ est décroissante, et on ajuste le paramètre croissance=False :

def f(x):
    return x**3 + 2 * x**2 - 4 * x - 1

dicho_general(f, -1, 0, 0.01, False)
                            

En exécutant ce code, on obtient un intervalle (par exemple, [-0.25 ; -0.2421875]) qui encadre la solution de $f(x)=0$ sur $[-1, 0]$, avec la précision demandée, démontrant la généralisation de notre algorithme de dichotomie.

Correction Question 1 :

Voici une implémentation possible pour la fonction dicho_decroiss(a, b, p) :

def dicho_decroiss(a, b, p):
    while b - a > p:
        m = (a + b) / 2
        if f(m) == 0:
            break
        elif f(m) > 0: # Condition modifiée pour fonction décroissante
            a = m
        else:
            b = m # Condition modifiée pour fonction décroissante
    if f(m) == 0:
        print(m,"est la solution recherchée")
    else:
        print("intervalle solution = [",a,",",b,"]")
                            

Correction Question 2 :

En exécutant dicho_decroiss(-1, 0, 0.05), on obtient un intervalle comme [-0.25, -0.1875]. Pour vérifier la cohérence, calculons $f(-0.25) \approx 0.046$ et $f(-0.1875) \approx -0.269$. Comme $f(-0.25) > 0$ et $f(-0.1875) < 0$, et que $f$ est décroissante sur $[-1, 0]$, le TVI confirme qu'un zéro existe dans cet intervalle. L'intervalle trouvé est donc cohérent.

Correction Question 3 :

La principale différence entre dicho_croiss et dicho_decroiss réside dans les conditions elif f(m) < 0: a = m (croissante) et elif f(m) > 0: a = m (décroissante), ainsi que la condition else: b = m adaptée en conséquence.
Pour une fonction croissante :

• Si $f(m) < 0$, le zéro (s'il existe) est à droite de $m$, donc on ajuste la borne inférieure $a = m$.
• Si $f(m) > 0$, le zéro est à gauche de $m$, donc on ajuste la borne supérieure $b = m$.

• Si $f(m) > 0$, le zéro (s'il existe) est à droite de $m$, donc on ajuste la borne inférieure $a = m$.
• Si $f(m) < 0$, le zéro est à gauche de $m$, donc on ajuste la borne supérieure $b = m$.

Correction Question 1 :

Pour calculer la probabilité d'obtenir exactement 3 succès en 10 épreuves avec une probabilité de succès de 0.4, on utilise la fonction binomiale comme suit :

probabilite = binomiale(3, 10, 0.4)
print("Probabilité d'obtenir exactement 3 succès : {:.4f}".format(probabilite))
                            

L'exécution de ce code affichera la probabilité calculée.

Correction Question 2 :

Pour un jeu de pile ou face équilibré lancé 5 fois, on calcule les probabilités d'obtenir de 0 à 5 faces :

for k in range(6): # Boucle de 0 à 5 succès
    probabilite_k = binomiale(k, 5, 0.5)
    print("P(X={0}) = {:.4f}".format(k, probabilite_k))
                            

Ce code affichera les probabilités pour chaque nombre possible de faces (de 0 à 5).

Correction Question 3 :

Vérifions que la somme des probabilités est égale à 1 :

somme_probabilites = 0
for k in range(6):
    somme_probabilites = somme_probabilites + binomiale(k, 5, 0.5)
print("Somme des probabilités : {:.4f}".format(somme_probabilites))
                            

La somme des probabilités est égale à 1 (ou très proche de 1). C'est logique car ces probabilités représentent tous les résultats possibles pour 5 lancers d'une pièce équilibrée (0 face, 1 face, 2 faces, 3 faces, 4 faces, ou 5 faces), et la somme des probabilités de tous les événements possibles dans un espace probabiliste doit toujours être égale à 1.

Correction Question 1 :

En exécutant SuiteProd(n) pour des valeurs croissantes de $n$, on observe que les valeurs de la suite augmentent, mais de plus en plus lentement.

Correction Question 2 :

Voici la fonction modifiée :

def SuiteProd_modifiee(n):
    u = 1
    print("i=0, u=1")
    for i in range(1, n + 1):
        u = u * (1 + 1/(i**2))
        print("i={0}, u={1}".format(i, u))
    return u
                            

Correction Question 3 :

En testant avec de grandes valeurs de $n$, on constate que la suite semble se stabiliser autour d'une valeur proche de 2.46. La suite $(u_n)$ semble converger vers une limite finie.

Correction Question 1 :

Calcul des premiers termes : $v_0 = 3$ $v_1 = (3 + 5) \pmod{7} = 8 \pmod{7} = 1$ $v_2 = (1 + 5) \pmod{7} = 6 \pmod{7} = 6$ $v_3 = (6 + 5) \pmod{7} = 11 \pmod{7} = 4$ $v_4 = (4 + 5) \pmod{7} = 9 \pmod{7} = 2$

Correction Question 2 :

def SuiteModulo(n):
    v = 3
    for _ in range(n):
        v = (v + 5) % 7
    return v
                            

Correction Question 3 :

for i in range(20):
    print("v_{0} = {1}".format(i, SuiteModulo(i)))
                            

En observant les premiers termes, on remarque la séquence : 3, 1, 6, 4, 2, 0, 5, 3, 1, 6, 4, 2, 0, 5, 3, 1, 6, 4, 2, 0. La suite semble périodique de période 7.

Correction Question 1 :

def SommeGeo(u0, q, n):
    somme = 0
    u = u0
    for _ in range(n + 1):
        somme = somme + u
        u = u * q
    return somme
                            

Correction Question 2 :

somme_calculee = SommeGeo(2, 0.5, 9) # Somme des 10 premiers termes (n=9 car on part de l'indice 0)
print("Somme calculée : {}".format(somme_calculee))
                            

Correction Question 3 :

La formule théorique pour la somme des $n+1$ premiers termes d'une suite géométrique est $S_n = u_0 \frac{1-q^{n+1}}{1-q}$. Pour $u_0 = 2$, $q = 0.5$ et $n = 9$, on a : $S_9 = 2 \times \frac{1 - (0.5)^{10}}{1 - 0.5} = 4 \times (1 - (0.5)^{10}) \approx 3.99609375$. La valeur calculée par SommeGeo doit être très proche de cette valeur théorique, confirmant la formule numériquement.

Correction Question 1 :

def SeuilSomme(seuil):
    N = 0
    w = 1
    somme_w = w # Somme initiale avec w_0
    while somme_w <= seuil:
        N = N + 1 # Incrementation modifiée
        w_next = w + 1/N
        w = w_next
        somme_w = somme_w + w # Ajout du nouveau terme à la somme
    return N
                            

Correction Question 2 :

print("Seuil 10 : N = {}".format(SeuilSomme(10)))
print("Seuil 50 : N = {}".format(SeuilSomme(50)))
print("Seuil 100 : N = {}".format(SeuilSomme(100)))
                            

On observe que $N$ augmente avec le seuil. Plus le seuil est élevé, plus il faut de termes pour que la somme le dépasse.

Correction Question 3 :

def SeuilSomme_modifiee(seuil):
    N = 0
    w = 1
    somme_w = w
    while somme_w <= seuil:
        N = N + 1 # Incrementation modifiée
        w_next = w + 1/N
        w = w_next
        somme_w = somme_w + w
    return N, somme_w # Retourne N et la somme atteinte
                            

Correction Question 1 :

def Syracuse_altitude(debut):
    u = debut
    termes = [u]
    temps_de_vol = 0
    altitude_max = debut # Altitude maximale initiale est le départ
    while u != 1:
        temps_de_vol = temps_de_vol + 1 # Incrementation modifiée
        if u % 2 == 0:
            u = u // 2
        else:
            u = 3 * u + 1
        termes.append(u)
        altitude_max = max(altitude_max, u) # Mise à jour de l'altitude maximale
    return temps_de_vol, termes, altitude_max
                            

Correction Question 2 :

departs = [15, 27, 40]
for debut in departs:
    temps_vol, termes, altitude_max = Syracuse_altitude(debut)
    print("Debut = {0}, Altitude maximale = {1}".format(debut, altitude_max))
                            

On observe que l'altitude maximale varie considérablement en fonction de la valeur de départ.

Correction Question 3 :

altitude_max_globale = 0
debut_max_altitude = 0
for debut in range(1, 1001):
    temps_vol, termes, altitude_max = Syracuse_altitude(debut)
    if altitude_max > altitude_max_globale:
        altitude_max_globale = altitude_max
        debut_max_altitude = debut
print("Départ produisant l'altitude maximale la plus élevée (jusqu'à 1000) : {0} avec une altitude de {1}".format(debut_max_altitude, altitude_max_globale))
                            

Correction Question 1 :

Graphiquement, ou en calculant $g(0) = \cos(0) - 0 = 1 > 0$ et $g(1) = \cos(1) - 1 \approx -0.459 < 0$. Puisque $g(0) > 0$ et $g(1) < 0$, et que $g(x)$ est continue et décroissante sur $[0, 1]$ (car sa dérivée $g'(x) = -\sin(x) - 1 < 0$ sur $[0, 1]$), le TVI assure l'existence d'un zéro unique dans cet intervalle.

Correction Question 2 :

import math
def g(x):
    return math.cos(x) - x

# Utiliser la fonction dicho_decroiss définie précédemment
intervalle_zero = dicho_decroiss(0, 1, 0.001)
print("Intervalle contenant le zéro de g(x) : {}".format(intervalle_zero))
                            

Correction Question 3 :

def dicho_decroiss_iterations(a, b, p):
    iterations = 0
    while b - a > p:
        m = (a + b) / 2
        if g(m) == 0:
            break
        elif g(m) > 0:
            a = m
        else:
            b = m
        iterations = iterations + 1 # Incrementation modifiée
    if g(m) == 0:
        print(m,"est la solution recherchée")
    else:
        print("intervalle solution = [",a,",",b,"]")
    return iterations, [a,b]
                            

Correction Question 1 :

La dérivée de $h(x) = x^2 + x$ est $h'(x) = 2x + 1$. Sur l'intervalle $[0, 2]$, $h'(x) = 2x + 1 > 0$, donc $h(x)$ est strictement croissante sur $[0, 2]$.

Correction Question 2 :

Pour trouver $x$ tel que $h(x) = 3$, on cherche le zéro de la fonction $f(x) = h(x) - 3 = x^2 + x - 3$. On utilise la dichotomie sur l'intervalle $[0, 2]$. On a $f(0) = -3 < 0$ et $f(2) = 4 + 2 - 3 = 3 > 0$, donc un zéro existe bien dans $[0, 2]$.

def h(x):
    return x**2 + x

def f_inversion(x): # Fonction pour l'inversion h(x) = 3
    return h(x) - 3

intervalle_solution = dicho_croiss(0, 2, 0.01)
print("Intervalle contenant la solution de h(x)=3 : {}".format(intervalle_solution))
                            

Correction Question 3 :

On prend le milieu de l'intervalle obtenu par la dichotomie comme valeur approchée de $x$. Par exemple, si l'intervalle est $[1.4453125 ; 1.453125]$, on prend $x \approx 1.4492$. Calculons $h(1.4492) = (1.4492)^2 + 1.4492 \approx 3.548$. Cette valeur est proche de 3, compte tenu de la précision demandée. (Note: il y a une erreur dans le calcul de l'exemple dans la question 3 de correction, la valeur devrait être proche de 3 et non 3.548, refaire le calcul avec un intervalle plus précis).

Correction Question 1 :

def Binomiale_cumulee(k, n, p):
    prob_cumulee = 0
    for i in range(k + 1):
        prob_cumulee = prob_cumulee + binomiale(i, n, p)
    return prob_cumulee
                            

Correction Question 2 :

prob_cumulee_4_faces = Binomiale_cumulee(4, 10, 0.5)
print("P(X <= 4) = {:.4f}".format(prob_cumulee_4_faces))
                            

Correction Question 3 :

prob_superieur_4_faces = 1 - Binomiale_cumulee(4, 10, 0.5) # P(X > 4) = 1 - P(X <= 4)
print("P(X > 4) = {:.4f}".format(prob_superieur_4_faces))
                            

Correction Question 1 :

def SeuilBinomiale(prob_seuil, p):
    n = 0
    prob_au_moins_un_succes = 0
    while prob_au_moins_un_succes < prob_seuil:
        n = n + 1 # Incrementation modifiée
        prob_au_moins_un_succes = 1 - binomiale(0, n, p) # P(X >= 1) = 1 - P(X = 0)
    return n
                            

Correction Question 2 :

n_min_epreuves = SeuilBinomiale(0.9, 0.1)
print("Nombre minimal d'épreuves nécessaires : {}".format(n_min_epreuves))
                            

Correction Question 3 :

La probabilité d'obtenir au moins un succès augmente avec le nombre d'épreuves $n$ car plus on répète l'expérience, plus on augmente les chances d'observer au moins une fois un succès. La probabilité de l'événement complémentaire (aucun succès) diminue à chaque épreuve supplémentaire, donc la probabilité de l'événement initial (au moins un succès) augmente.

Correction Question 1 :

prob_defectueuse = 0.05
taille_echantillon = 20
prob_2_defectueuses = binomiale(2, taille_echantillon, prob_defectueuse)
print("Probabilité d'avoir exactement 2 pièces défectueuses : {:.4f}".format(prob_2_defectueuses))
                            

Correction Question 2 :

prob_au_plus_2_defectueuses = Binomiale_cumulee(2, taille_echantillon, prob_defectueuse)
print("Probabilité d'avoir au plus 2 pièces défectueuses : {:.4f}".format(prob_au_plus_2_defectueuses))
                            

Correction Question 3 :

prob_plus_de_2_defectueuses = 1 - Binomiale_cumulee(2, taille_echantillon, prob_defectueuse)
print("Probabilité d'avoir plus de 2 pièces défectueuses : {:.4f}".format(prob_plus_de_2_defectueuses))