Exercices corrigés — Algorithmique et Python (Première)

range(4) fait prendre à k les valeurs 0, 1, 2, 3 : le corps de la boucle est exécuté quatre fois. À chaque passage, u est remplacé par 3*u - 1.

le corps de la fonction calcule bien x**2, mais ce résultat n'est ni stocké ni renvoyé : il est calculé puis oublié. En l'absence d'instruction return, Python renvoie la valeur spéciale None, et carre(3) ne vaut pas 9.
Version corrigée :

def carre(x):
    return x**2

Test : carre(3) renvoie 9 et carre(-2) renvoie 4.
Ne pas confondre return, qui transmet une valeur au programme appelant (on peut écrire y = carre(3)), et print, qui se contente d'afficher : une fonction qui ferait print(x**2) afficherait 9 mais y = carre(3) donnerait encore None.

a) On traduit l'expression en Python, où la puissance s'écrit ** et la multiplication * est obligatoire :

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

b) La compréhension parcourt range(6), qui donne les entiers de 0 à 5 inclus (la borne 6 est exclue) : L = [image_g(k) for k in range(6)].
c) On calcule g(0) = 1, g(1) = 3 − 2 + 1 = 2, g(2) = 12 − 4 + 1 = 9, g(3) = 27 − 6 + 1 = 22, g(4) = 48 − 8 + 1 = 41, g(5) = 75 − 10 + 1 = 66. La liste est [1, 2, 9, 22, 41, 66].
Cette liste est un tableau de valeurs : L[3] vaut 22, image de 3 (les indices commencent à 0). Elle sert à tracer la parabole ou à repérer un changement de signe.

on parcourt la liste avec une boucle for et l'on incrémente un compteur, initialisé à 0 avant la boucle, à chaque terme strictement positif :

def compte_positifs(L):
    compteur = 0
    for x in L:
        if x > 0:
            compteur = compteur + 1
    return compteur

Déroulement pour [3, -1, 0, 7] : 3 > 0, compteur = 1 ; −1 > 0 est faux ; 0 > 0 est faux (0 n'est pas strictement positif) ; 7 > 0, compteur = 2. La fonction renvoie 2.
Erreurs à éviter : oublier l'initialisation compteur = 0 (erreur à l'exécution), écrire x >= 0 (0 serait compté), ou placer return dans la boucle (la fonction s'arrêterait au premier terme). Pour une liste vide, la boucle ne s'exécute pas et la fonction renvoie 0, ce qui est correct.

a) Perdre 10 %, c'est multiplier par 0,9 : après k passages, u vaut 1 000 × 0,9^k, la valeur du capital après k années, et n vaut k.
b) La boucle continue tant que le capital dépasse 500 €. Valeurs successives (arrondies) : 900 ; 810 ; 729 ; 656,1 ; 590,5 ; 531,4 ; 478,3. Après le sixième passage, u ≈ 531,4 > 500, on continue ; après le septième, u ≈ 478,3 ≤ 500, la condition devient fausse et la boucle s'arrête.
Le script affiche 7 478.296... : le capital passe sous la moitié de sa valeur initiale au bout de 7 ans.
c) À chaque passage, u est multiplié par 0,9 < 1 : les valeurs 1 000 × 0,9ⁿ deviennent aussi petites que l'on veut, donc elles finissent par passer sous 500. Une boucle while n'est correcte que si une telle garantie existe ; avec u = 1.1*u, le capital augmenterait et la boucle ne s'arrêterait jamais.

au départ, f(1) = −1 < 0 et f(2) = 2 > 0 : f change de signe sur [1 ; 2], et f est continue et strictement croissante sur cet intervalle, donc l'équation f(x) = 0 y a une unique solution, √2.
Passage 1 : b - a = 1 > 0,25 ; m = 1,5 ; f(1,5) = 2,25 − 2 = 0,25. Le produit f(1) × f(1,5) = −0,25 est négatif : la racine est dans [1 ; 1,5], on pose b = 1.5.
Passage 2 : b - a = 0,5 > 0,25 ; m = 1,25 ; f(1,25) = 1,5625 − 2 = −0,4375. Le produit f(1) × f(1,25) est positif : la racine est dans [1,25 ; 1,5], on pose a = 1.25.
Ensuite b - a = 0,25, qui n'est pas strictement supérieur à 0,25 : la boucle s'arrête. La fonction renvoie (a + b) / 2 = 1,25 + 1,52 = 1,375. C'est une valeur approchée de √2 ≈ 1,4142 à 0,125 près (la moitié de la longueur du dernier intervalle). Avec precision = 0.001, il faudrait 10 passages, car 12¹⁰ < 0,001.

chaque série se simule par trois appels indépendants à bernoulli(0.7), dont la somme s est le nombre de succès ; on compte les séries où s vaut 2 :

def estimation(N):
    favorables = 0
    for repetition in range(N):
        s = bernoulli(0.7) + bernoulli(0.7) + bernoulli(0.7)
        if s == 2:
            favorables = favorables + 1
    return favorables / N

Valeur théorique : les chemins avec exactement deux succès sont SSE, SES et ESS, chacun de probabilité 0,7² × 0,3 = 0,147 ; la probabilité vaut 3 × 0,147 = 0,441.
Pour N grand, la fréquence renvoyée fluctue autour de 0,441 : par exemple 0,4378 ou 0,4452 pour N = 10 000. Deux exécutions donnent des résultats différents, et la fluctuation diminue quand N augmente. La simulation confirme le calcul mais ne le remplace pas : elle donne une valeur approchée, l'arbre donne la valeur exacte.

a) L'écart type de la moyenne de n = 100 lancers est σ√n ≈ 1,7110 = 0,171. La zone à deux écarts types est [3,5 − 0,342 ; 3,5 + 0,342] ≈ [3,16 ; 3,84].
b) Dans les situations usuelles, environ 95 % des moyennes d'échantillon tombent dans la zone à deux écarts types : sur 1 000 échantillons, on attend de l'ordre de 950 moyennes entre 3,16 et 3,84, les autres s'en écartant par fluctuation d'échantillonnage.
c) On parcourt la liste et l'on compte les moyennes dont l'écart à 3,5 ne dépasse pas 0,342 :

def proportion_dans_zone(L):
    dedans = 0
    for m in L:
        if abs(m - 3.5) <= 0.342:
            dedans = dedans + 1
    return dedans / len(L)

L'appel proportion_dans_zone(echantillons(100, 1000)) renvoie une valeur proche de 0,95. En remplaçant 100 par 400, l'écart type de la moyenne est divisé par 2 et la zone se resserre à [3,33 ; 3,67], mais la proportion reste voisine de 0,95 : c'est la concentration des moyennes autour de μ que l'on observe.