$course$/QCM de maths/Terminale spécialité/Algorithmique et programmation Listes (génération, manipulation, parcours) et algorithmes du
programme : dichotomie, méthodes de Newton et de la sécante, méthode
d'Euler, méthodes des rectangles et des trapèzes, Monte-Carlo, seuil
d'une loi binomiale et surréservation, simulation d'échantillons,
marche aléatoire, planche de Galton.

]]> Algorithmique et programmation — Q01 : Les termes d'une suite en compréhension La suite (uₙ) est définie par uₙ = 1/n + 1. Que
contient la liste [1 / (n + 1) for n in range(4)] ?

]]> [expression for n in range(p)] fournit la liste des termes
d'indices 0 à p - 1.

]]> 1.0 0.0 0 true true abc La somme u₀ + u₁ + u₂ + u₃

]]> Erreur : une liste en compréhension range chaque valeur
séparément. La somme s'obtiendrait avec sum.

]]> Les termes u₀ à u₄

]]> Erreur : range(4) produit quatre valeurs, de 0 à 3. Le
terme u₄ n'est pas calculé.

]]> Les termes u₁, u₂, u₃ et u₄

]]> Erreur : range(4) commence à 0, donc le premier terme est
u₀ = 1.

]]> Les termes u₀, u₁, u₂ et u₃

]]> Bonne réponse : n prend les valeurs 0 à 3, soit 1,
0{,}5, 0{,}333\ldots et 0{,}25.

]]> Algorithmique et programmation — Q02 : Lister des couples Combien d'éléments contient la liste
[(a, b) for a in range(1, 4) for b in range(1, 3)] ?

]]> Deux boucles dans une compréhension parcourent le produit cartésien
\{1, 2, 3\} \times \{1, 2\} : c'est le principe multiplicatif.

]]> 1.0 0.0 0 true true abc 5

]]> Erreur : les deux choix se combinent. On multiplie les nombres
de valeurs, on ne les additionne pas.

]]> 9

]]> Erreur : range(1, 3) ne produit que 1 et 2, soit deux
valeurs pour b.

]]> 6

]]> Bonne réponse : a prend 3 valeurs et b en prend 2 ; la
liste contient les 3 × 2 = 6 couples du produit cartésien.

]]> 12

]]> Erreur : les bornes de droite sont exclues : a va de 1 à
3 et b de 1 à 2.

]]> Algorithmique et programmation — Q03 : Filtrer une liste Que renvoie f([3, -1, 4, -5, 2]) ?

`python def f(L): R = [] for x in L: if x > 0: R.append(x) return R`

]]> On obtient la même liste en compréhension :
[x for x in L if x > 0].

]]> 1.0 0.0 0 true true abc [-1, -5]

]]> Erreur : la condition x > 0 retient les éléments positifs, pas
les négatifs.

]]> [2, 3, 4]

]]> Erreur : la liste R n'est pas triée ; l'ordre de L est
conservé.

]]> [3, 4, 2]

]]> Bonne réponse : la fonction parcourt L et recopie dans R les
éléments strictement positifs, dans l'ordre.

]]> 3

]]> Erreur : 3 est le nombre d'éléments retenus. La fonction
renvoie la liste elle-même.

]]> Algorithmique et programmation — Q04 : Tester la monotonie sur une liste La liste U contient les premiers termes d'une suite. Que teste la
fonction suivante ?

`python def test(U): for i in range(len(U) - 1): if U[i + 1] < U[i]: return False return True`

]]> L'indice i s'arrête à len(U) - 2 pour que U[i + 1] existe. Un
test sur quelques termes permet de conjecturer, pas de démontrer.

]]> 1.0 0.0 0 true true abc Si la liste contient un terme négatif

]]> Erreur : chaque terme est comparé à son voisin, pas à 0.

]]> Si la suite est croissante pour tout entier n

]]> Erreur : seuls les termes de la liste sont examinés. Le résultat
ne démontre rien sur les termes suivants.

]]> Si la liste est rangée par ordre croissant

]]> Bonne réponse : la fonction renvoie False dès qu'un terme est
plus petit que le précédent, True sinon.

]]> Si la suite est décroissante sur la liste

]]> Erreur : un terme plus petit que son prédécesseur fait renvoyer
False. La fonction reconnaît l'ordre croissant.

]]> Algorithmique et programmation — Q05 : Insérer et supprimer Que contient L après ces instructions ?

`python L = [2, 4, 6, 8] L.insert(1, 3) del L[3]`

]]> L.insert(i, x) place x à l'indice i en décalant la suite ;
del L[i] supprime l'élément d'indice i.

]]> 1.0 0.0 0 true true abc [2, 3, 4, 8]

]]> Bonne réponse : après l'insertion de 3 à l'indice 1, la
liste est [2, 3, 4, 6, 8] ; l'élément d'indice 3 est 6,
que l'on supprime.

]]> [2, 3, 6, 8]

]]> Erreur : les indices ont été lus sur la liste de départ. Après
l'insertion, les éléments suivants sont décalés d'un rang.

]]> [3, 2, 4, 6]

]]> Erreur : L.insert(1, 3) place la valeur 3 à l'indice 1,
juste après le premier élément.

]]> [2, 3, 4, 6]

]]> Erreur : del L[3] supprime l'élément d'indice 3, pas le
dernier.

]]> Algorithmique et programmation — Q06 : Le principe de la dichotomie La fonction f est continue et strictement croissante sur
[1 ; 2], avec f(1) < 0 < f(2) et f(1{,}5) > 0. Dans quel
intervalle la dichotomie poursuit-elle la recherche de la solution
de f(x) = 0 ?

]]> Dichotomie : on calcule l'image du milieu et l'on garde la moitié
aux bornes de laquelle f prend des valeurs de signes contraires.

]]> 1.0 0.0 0 true true abc [1\,;\,1{,}5]

]]> Bonne réponse : f change de signe entre 1 et 1{,}5, donc la
solution s'y trouve d'après le théorème des valeurs
intermédiaires.

]]> [1 ; 2], sans changement

]]> Erreur : le calcul de f(1{,}5) sert justement à diviser la
longueur de l'intervalle par deux.

]]> [1{,}25\,;\,1{,}75]

]]> Erreur : la dichotomie garde toujours une des deux moitiés de
l'intervalle, celle où f change de signe.

]]> [1{,}5\,;\,2]

]]> Erreur : f(1{,}5) et f(2) sont tous deux positifs, f ne
s'annule pas entre ces deux valeurs.

]]> Algorithmique et programmation — Q07 : Compléter une dichotomie La fonction f est continue sur [a ; b] et f(a) × f(b) < 0.
Quelle ligne compléter ?

`python def dicho(a, b, e): while b - a > e: m = (a + b) / 2 if f(a) * f(m) <= 0: b = m else: ... return a, b`

]]> À chaque tour, la longueur b - a est divisée par 2 ; la boucle
s'arrête quand elle ne dépasse plus la précision e.

]]> 1.0 0.0 0 true true abc a = m

]]> Bonne réponse : si f(a) et f(m) ont le même signe, le
changement de signe a lieu entre m et b : on remplace a
par m.

]]> b = a

]]> Erreur : l'intervalle serait réduit à un point, sans garantie
qu'il contienne la solution.

]]> m = a

]]> Erreur : modifier m ne change pas l'intervalle, et la boucle
ne se termine jamais.

]]> a = b

]]> Erreur : la boucle s'arrêterait avec un intervalle de longueur
nulle, placé à la mauvaise extrémité.

]]> Algorithmique et programmation — Q08 : Nombre d'étapes d'une dichotomie On part de l'intervalle [0 ; 1]. Combien d'étapes de dichotomie
faut-il au minimum pour obtenir un intervalle de longueur inférieure
ou égale à 10⁻³ ?

]]> On cherche le plus petit n tel que 2ⁿ ≥ 1 000, soit
n \geq \dfrac{\ln 1\,000}{\ln 2} \approx 9{,}97, d'où n = 10.

]]> 1.0 0.0 0 true true abc 10

]]> Bonne réponse : après n étapes, la longueur vaut
1/2ⁿ ; 2⁹ = 512 ne suffit pas, 2¹⁰ = 1 024
suffit.

]]> 3

]]> Erreur : chaque étape divise la longueur par 2, pas par 10.

]]> 1 000

]]> Erreur : la longueur ne diminue pas de 10⁻³ par étape, elle
est divisée par 2.

]]> 9

]]> Erreur : 1/2⁹ = 1/512, qui est encore
supérieur à 10⁻³.

]]> Algorithmique et programmation — Q09 : Une étape de Newton pour racine de trois La méthode de Newton pour f(x) = x² - 3 s'écrit
xₙ₊₁ = xₙ - xₙ² - 3/2xₙ. Avec x₀ = 2, que vaut
x₁ ?

]]> La méthode de Newton remplace xₙ par l'abscisse du point où la
tangente en xₙ coupe l'axe des abscisses. La convergence est
très rapide dans les cas favorables.

]]> 1.0 0.0 0 true true abc 1{,}75

]]> Bonne réponse : x_1 = 2 - \dfrac{4 - 3}{4} = 2 - 0{,}25.
C'est déjà une bonne approximation de \sqrt{3} \approx 1{,}732.

]]> 2{,}25

]]> Erreur de signe : on retranche le quotient
f(x₀)/f'(x₀), on ne l'ajoute pas.

]]> 1{,}5

]]> Erreur : le dénominateur est 2x₀ = 4, pas 2.

]]> √3

]]> Erreur : √3 est la limite de la suite. Une étape n'en
donne qu'une valeur approchée.

]]> Algorithmique et programmation — Q10 : La méthode de la sécante La méthode de la sécante approche une solution de f(x) = 0 à
partir de deux valeurs a et b. Par quoi remplace-t-elle la
tangente de la méthode de Newton ?

]]> La pente de la sécante, f(b) - f(a)/b - a, remplace le
nombre dérivé : c'est une méthode de Newton sans dérivée.

]]> 1.0 0.0 0 true true abc Par la droite passant par (a ; f(a)) et (b ; f(b))

]]> Bonne réponse : on prend l'abscisse du point où cette droite
coupe l'axe des abscisses, sans avoir besoin de la dérivée.

]]> Par le milieu a + b/2, comme en dichotomie

]]> Erreur : c'est la dichotomie. La sécante tient compte des
valeurs f(a) et f(b), pas seulement des bornes.

]]> Par l'axe des abscisses, sans utiliser la courbe

]]> Erreur : l'axe des abscisses ne dépend pas de f, il ne peut
donc pas localiser une solution.

]]> Par la tangente au milieu de [a ; b]

]]> Erreur : une tangente demande encore le calcul de la dérivée,
que la sécante permet d'éviter.

]]> Algorithmique et programmation — Q11 : Un pas de la méthode d'Euler La fonction y vérifie y' = -2y + 4 et y(0) = 1. La méthode
d'Euler de pas h = 0{,}1 utilise y(x + h) ≈ y(x) + h y'(x).
Quelle valeur approchée de y(0{,}1) donne-t-elle ?

]]> Méthode d'Euler pour y' = ay + b :
yₖ₊₁ = yₖ + h(ayₖ + b). On calcule ainsi, pas à pas, une
approximation de la solution.

]]> 1.0 0.0 0 true true abc 0{,}8

]]> Erreur de signe : y'(0) = 2 est positif, donc y augmente sur
ce premier pas.

]]> 3

]]> Erreur : l'accroissement y'(0) = 2 doit être multiplié par le
pas h = 0{,}1.

]]> 1{,}2

]]> Bonne réponse : y'(0) = -2 × 1 + 4 = 2, donc
y(0{,}1) \approx 1 + 0{,}1 \times 2.

]]> 1{,}4

]]> Erreur : le second membre 4 a été ajouté sans le terme
-2y(0) : on a pris y'(0) = 4.

]]> Algorithmique et programmation — Q12 : Programmer la méthode d'Euler Quelle ligne compléter pour que euler(n) renvoie une valeur
approchée de y(1), où y' = y et y(0) = 1, avec n pas de
longueur 1/n ?

`python def euler(n): h = 1 / n y = 1 for k in range(n): ... return y`

]]> Plus n est grand, plus l'approximation de y(1) = e est précise :
n = 1 000 donne environ 2{,}717.

]]> 1.0 0.0 0 true true abc y = y + h

]]> Erreur : cette ligne correspond à y' = 1. On obtiendrait 2,
la valeur en 1 de x ↦ 1 + x.

]]> y = h * y

]]> Erreur : on doit ajouter l'accroissement h y à la valeur
actuelle, pas la remplacer par cet accroissement.

]]> y = y * (1 + k)

]]> Erreur : le pas h n'intervient plus. On calculerait une
factorielle, sans rapport avec l'équation.

]]> y = y + h * y

]]> Bonne réponse : ici y' = y, donc chaque pas ajoute h × y.
On obtient (1 + 1/n)ⁿ, proche de e.

]]> Algorithmique et programmation — Q13 : La méthode des rectangles On approche \displaystyle\int_0^1 x^2\,dx par la somme des aires de
4 rectangles de largeur 0{,}25, dont la hauteur est l'image de la
borne gauche de chaque intervalle. Quelle valeur obtient-on ?

]]> La fonction carré étant croissante sur [0 ; 1], les rectangles à
gauche donnent une valeur par défaut et ceux à droite une valeur
par excès : 0{,}21875 \leq \dfrac{1}{3} \leq 0{,}46875.

]]> 1.0 0.0 0 true true abc 0{,}875

]]> Erreur : la somme des hauteurs n'a pas été multipliée par la
largeur 0{,}25 des rectangles.

]]> 0{,}21875

]]> Bonne réponse :
0{,}25 \times (0 + 0{,}0625 + 0{,}25 + 0{,}5625) = 0{,}21875.

]]> 0{,}46875

]]> Erreur : ce sont les bornes droites, 0{,}25, 0{,}5,
0{,}75 et 1, qui ont été utilisées.

]]> ⅓

]]> Erreur : c'est la valeur exacte de l'intégrale. La méthode des
rectangles en donne une approximation.

]]> Algorithmique et programmation — Q14 : Programmer la méthode des rectangles Que calcule rect(0, 1, 100) pour une fonction f continue sur
[0 ; 1] ?

`python def rect(a, b, n): h = (b - a) / n s = 0 for k in range(n): s = s + h f(a + k h) return s`

]]> Quand n augmente, la somme des aires des rectangles se rapproche de
l'intégrale. Les méthodes des milieux et des trapèzes convergent plus
vite.

]]> 1.0 0.0 0 true true abc Une valeur approchée de \displaystyle\int_0^1 f(x)\,dx

]]> Bonne réponse : la fonction additionne les aires de 100
rectangles de largeur h = 0{,}01, de hauteur l'image de la
borne gauche.

]]> La somme des images f(0), f(0{,}01), …, f(0{,}99)

]]> Erreur : chaque image est multipliée par la largeur h : on
additionne des aires, pas des hauteurs.

]]> La valeur exacte de \displaystyle\int_0^1 f(x)\,dx

]]> Erreur : une somme de rectangles ne donne qu'une approximation,
sauf cas particulier comme une fonction constante.

]]> La valeur moyenne des images f(0) et f(1)

]]> Erreur : la fonction utilise les images de 100 points de
l'intervalle, pas seulement celles des bornes.

]]> Algorithmique et programmation — Q15 : La méthode des trapèzes On approche \displaystyle\int_0^2 f(x)\,dx par un seul trapèze, de
sommets (0 ; 0), (2 ; 0), (2 ; f(2)) et (0 ; f(0)).
Avec f(0) = 1 et f(2) = 5, quelle valeur obtient-on ?

]]> Méthode des trapèzes sur [a ; b] :
\displaystyle\int_a^b f \approx (b - a) \dfrac{f(a) + f(b)}{2},
appliquée sur chaque petit intervalle d'une subdivision.

]]> 1.0 0.0 0 true true abc 6

]]> Bonne réponse : l'aire du trapèze vaut
2 × f(0) + f(2)/2 = 2 × 3.

]]> 10

]]> Erreur : c'est l'aire du rectangle de hauteur f(2), qui
majore le trapèze.

]]> 3

]]> Erreur : 3 est la hauteur moyenne. Il faut la multiplier par la
largeur 2.

]]> 12

]]> Erreur : la somme des deux bases est divisée par 2 dans la
formule du trapèze.

]]> Algorithmique et programmation — Q16 : Une intégrale par Monte-Carlo Le module random est importé. La fonction f est continue sur
[0 ; 1] et vérifie 0 ≤ f(x) ≤ 1. Que renvoie
mc(100000), environ ?

`python def mc(n): c = 0 for i in range(n): x = random.random() y = random.random() if y <= f(x): c = c + 1 return c / n`

]]> Méthode de Monte-Carlo : l'aire du carré unité vaut 1, donc la
proportion de points sous la courbe estime directement l'intégrale.

]]> 1.0 0.0 0 true true abc Le maximum de f sur [0 ; 1]

]]> Erreur : la fonction compte des points, elle ne cherche aucun
maximum.

]]> f(0{,}5), la valeur au milieu

]]> Erreur : les abscisses sont tirées au hasard dans tout
l'intervalle, pas seulement au milieu.

]]> 1 - \displaystyle\int_0^1 f(x)\,dx

]]> Erreur : ce serait la fréquence des points au-dessus de la
courbe, avec la condition y > f(x).

]]> \displaystyle\int_0^1 f(x)\,dx

]]> Bonne réponse : la fréquence des points du carré unité situés sous
la courbe approche l'aire sous la courbe, qui est l'intégrale.

]]> Algorithmique et programmation — Q17 : Seuil pour une suite convergente La suite définie par u₀ = 0 et u_{n+1} = 0{,}5\,u_n + 3
converge vers 6. Que renvoie la fonction suivante ?

`python def rang(): u = 0 n = 0 while 6 - u > 0.01: u = 0.5 * u + 3 n = n + 1 return n`

]]> On a 6 - u_n = 6 \times 0{,}5^n ; 6 \times 0{,}5^9 \approx 0{,}0117
et 6 \times 0{,}5^{10} \approx 0{,}0059, donc la fonction renvoie
10.

]]> 1.0 0.0 0 true true abc Le terme uₙ le plus proche de 6

]]> Erreur : la fonction renvoie le compteur n, pas le terme u.

]]> La limite de la suite, arrondie au centième

]]> Erreur : la fonction renvoie n, un rang, et non une valeur de
la suite.

]]> Le premier rang où 6 - u_n \leq 0{,}01

]]> Bonne réponse : ici 6 - u_n = 6 \times 0{,}5^n, et la boucle
s'arrête dès que cet écart ne dépasse plus 0{,}01 : n = 10.

]]> Rien, car la suite n'atteint jamais 6

]]> Erreur : la boucle ne demande pas d'atteindre 6, seulement de
s'en approcher à moins de 0{,}01, ce qui arrive.

]]> Algorithmique et programmation — Q18 : Calculer une probabilité binomiale On dispose d'une fonction comb(n, k) qui renvoie
\dbinom{n}{k}. Quelle expression Python calcule P(X = k) lorsque
X suit la loi binomiale \mathcal{B}(n, p) ?

]]> Une liste de n issues avec k succès a pour probabilité
p^k(1 - p)^{n - k}, et il y a \dbinom{n}{k} telles listes.

]]> 1.0 0.0 0 true true abc comb(n, k) p k (1 - p) (n - k)

]]> Erreur : est la multiplication. La puissance s'écrit *.

]]> comb(n, k) p k (1 - p) ** (n - k)

]]> Bonne réponse : P(X = k) = \dbinom{n}{k} p^k (1 - p)^{n - k}.

]]> p * k (1 - p) ** (n - k)

]]> Erreur : c'est la probabilité d'une liste d'issues. Il faut
multiplier par le nombre de listes à k succès, \dbinom{n}{k}.

]]> comb(n, k) p k (1 - p) ** k

]]> Erreur : l'exposant de 1 - p est le nombre d'échecs, n - k.

]]> Algorithmique et programmation — Q19 : Probabilité cumulée par une boucle La fonction pbin(n, p, k) renvoie P(X = k) pour
X \sim \mathcal{B}(n, p). Que calcule la fonction suivante ?

`python def f(n, p, k): s = 0 for i in range(k + 1): s = s + pbin(n, p, i) return s`

]]> Probabilité cumulée : P(X \leq k) = \sum_{i = 0}^{k} P(X = i). Les
calculatrices la fournissent directement.

]]> 1.0 0.0 0 true true abc P(X ≤ k)

]]> Bonne réponse : la boucle additionne P(X = i) pour i allant
de 0 à k.

]]> P(X < k)

]]> Erreur : range(k + 1) va jusqu'à k inclus, donc P(X = k)
est ajoutée.

]]> P(X = k)

]]> Erreur : P(X = k) n'est qu'un des termes de la somme calculée.

]]> P(X ≥ k)

]]> Erreur : les valeurs additionnées vont de 0 à k, ce sont les
petites valeurs de X.

]]> Algorithmique et programmation — Q20 : Le problème de la surréservation Une compagnie vend n billets pour un avion de k places ; le
nombre X de passagers qui se présentent suit une loi binomiale.
La fonction F(j) renvoie P(X ≤ j). Que renvoie la fonction
suivante, pour \alpha = 0{,}05 ?

`python def seuil(alpha): k = 0 while 1 - F(k) > alpha: k = k + 1 return k`

]]> Avec k places, le risque de refuser un passager est
P(X > k) ; la compagnie choisit le plus petit nombre de places
qui rend ce risque inférieur à α.

]]> 1.0 0.0 0 true true abc Le plus grand k tel que P(X > k) \leq 0{,}05

]]> Erreur : k augmente à partir de 0 et la boucle s'arrête dès
que la condition est remplie : c'est le plus petit k.

]]> Le plus petit k tel que P(X > k) \leq 0{,}05

]]> Bonne réponse : 1 - F(k) = P(X > k). La boucle s'arrête au
premier k pour lequel ce risque ne dépasse plus 0{,}05.

]]> Le nombre moyen de passagers qui se présentent

]]> Erreur : la moyenne est l'espérance np. La fonction cherche un
seuil de risque.

]]> Le plus petit k tel que P(X \leq k) \leq 0{,}05

]]> Erreur : 1 - F(k) est la probabilité de l'événement contraire,
P(X > k).

]]> Algorithmique et programmation — Q21 : Un intervalle de forte probabilité Pour X \sim \mathcal{B}(100\,;\,0{,}5), on lit à la calculatrice
P(X \leq 39) \approx 0{,}018 et P(X \leq 60) \approx 0{,}982. Que
peut-on affirmer ?

]]> P(a ≤ X ≤ b) = P(X ≤ b) - P(X ≤ a - 1) pour une
variable à valeurs entières. On obtient ainsi un intervalle I tel
que P(X ∈ I) ≥ 1 - α, ici avec \alpha \approx 0{,}04.

]]> 1.0 0.0 0 true true abc P(40 \leq X \leq 60) \approx 0{,}964

]]> Bonne réponse : P(40 ≤ X ≤ 60) = P(X ≤ 60) - P(X ≤ 39), soit environ 0{,}982 - 0{,}018.

]]> P(40 \leq X \leq 60) \approx 0{,}982

]]> Erreur : il faut retirer les valeurs inférieures à 40, de
probabilité 0{,}018.

]]> P(40 ≤ X ≤ 60) ≈ 1

]]> Erreur : les valeurs hors de [40 ; 60] ne sont pas
impossibles : leur probabilité totale est d'environ 0{,}036.

]]> P(39 \leq X \leq 60) \approx 0{,}964

]]> Erreur : en retranchant P(X ≤ 39), on retire aussi la
valeur 39 ; l'intervalle commence à 40.

]]> Algorithmique et programmation — Q22 : Simuler un échantillon Le module random est importé. Que renvoie ech(50, 0.3) ?

`python def ech(n, p): L = [] for i in range(n): if random.random() < p: L.append(1) else: L.append(0) return L`

]]> sum(ech(n, p)) simule une variable de loi \mathcal{B}(n, p) et
sum(ech(n, p)) / n une fréquence observée.

]]> 1.0 0.0 0 true true abc Le nombre de succès en 50 épreuves

]]> Erreur : la fonction renvoie la liste des résultats. Le nombre
de succès s'obtiendrait avec sum.

]]> Une liste contenant exactement 15 fois le nombre 1

]]> Erreur : 15 est le nombre moyen de succès. Le nombre obtenu
varie d'une simulation à l'autre.

]]> Une liste de 50 nombres compris entre 0 et 0{,}3

]]> Erreur : les éléments valent 1 ou 0 selon la comparaison de
random.random() avec p.

]]> Une liste de 50 valeurs égales à 0 ou 1

]]> Bonne réponse : chaque élément vaut 1 avec probabilité 0{,}3
et 0 sinon ; c'est un échantillon de taille 50.

]]> Algorithmique et programmation — Q23 : Dispersion des moyennes simulées On simule un grand nombre d'échantillons de taille n d'une
variable d'écart type σ et l'on calcule l'écart type s des
moyennes obtenues. Autour de quelle valeur s se situe-t-il ?

]]> La simulation confirme le résultat du cours : pour quadrupler la
précision de la moyenne, il faut un échantillon seize fois plus
grand.

]]> 1.0 0.0 0 true true abc \dfrac{\sigma}{\sqrt{n}}

]]> Bonne réponse : la moyenne d'un échantillon a pour variance
σ²/n, donc pour écart type
\dfrac{\sigma}{\sqrt{n}}.

]]> σ√n

]]> Erreur : σ√n est l'écart type de la somme des
n valeurs, pas de leur moyenne.

]]> σ/n

]]> Erreur : c'est la variance qui est divisée par n. L'écart
type l'est par √n.

]]> σ²/n

]]> Erreur : σ²/n est la variance de la moyenne.
L'écart type en est la racine carrée.

]]> Algorithmique et programmation — Q24 : Une marche aléatoire Le module random est importé. Un pion part de 0 et fait n pas
de +1 ou de -1 avec la même probabilité. Que renvoie
marche(10) ?

`python def marche(n): x = 0 for i in range(n): if random.random() < 0.5: x = x + 1 else: x = x - 1 return x`

]]> Si D est le nombre de pas vers la droite, la position vaut
D - (10 - D) = 2D - 10, avec D \sim \mathcal{B}(10\,;\,0{,}5).
On peut donc calculer la loi de la position.

]]> 1.0 0.0 0 true true abc Toujours 0, les pas se compensant

]]> Erreur : les pas ne se compensent qu'en moyenne. L'espérance de
la position vaut 0, mais la position varie d'une simulation à
l'autre.

]]> La position du pion après 10 pas

]]> Bonne réponse : x part de 0 et change de ± 1 à chaque pas.
Sa valeur finale est un entier pair compris entre -10 et 10.

]]> Le nombre de pas vers la droite

]]> Erreur : les pas vers la gauche diminuent x, qui n'est donc
pas un simple compteur.

]]> La distance totale parcourue, égale à 10

]]> Erreur : la fonction renvoie une position, qui tient compte du
sens de chaque pas.

]]> Algorithmique et programmation — Q25 : La planche de Galton Dans une planche de Galton à 6 rangées de clous, une bille part à
droite ou à gauche avec probabilité ½ à chaque clou,
de façon indépendante. Quelle loi suit le nombre X de rebonds à
droite ?

]]> La case d'arrivée d'une bille est déterminée par son nombre de
rebonds à droite. La simulation de nombreuses billes fait apparaître
la forme en cloche de la loi binomiale.

]]> 1.0 0.0 0 true true abc La loi binomiale \mathcal{B}\left(6\,;\,\dfrac{1}{2}\right)

]]> Bonne réponse : 6 épreuves de Bernoulli identiques et
indépendantes, le succès étant « aller à droite ».

]]> Une loi qui dépend de la case de départ

]]> Erreur : toutes les billes partent du même point, et les rebonds
suivent la même règle à chaque clou.

]]> La loi binomiale \mathcal{B}\left(\dfrac{1}{2}\,;\,6\right)

]]> Erreur : l'ordre des paramètres est inversé. On écrit d'abord le
nombre d'épreuves, puis la probabilité du succès.

]]> La loi uniforme sur \{0, 1, \ldots, 6\}

]]> Erreur : les cases du milieu reçoivent bien plus de billes que
les bords, P(X = 3) = 20/64 contre
P(X = 0) = 1/64.

]]> Algorithmique et programmation — Q26 : Comparer une fréquence observée à la borne Pour S_n \sim \mathcal{B}(n\,;\,p), l'inégalité de
Bienaymé-Tchebychev donne
P(|Sₙ - np| ≥ √n) ≤ p(1 - p). Avec
p = 0{,}5, une simulation donne une fréquence de cet événement
proche de 0{,}05. Qu'en conclure ?

]]> Ici V(Sₙ) = np(1 - p) et l'écart vaut √n : la borne est
\dfrac{np(1 - p)}{n} = p(1 - p) = 0{,}25. L'inégalité est
universelle, donc rarement précise.

]]> 1.0 0.0 0 true true abc La borne 0{,}25 est respectée, mais large

]]> Bonne réponse : 0{,}05 \leq 0{,}25. L'inégalité est vraie mais
grossière, la probabilité réelle étant bien plus petite.

]]> La probabilité vaut exactement 0{,}25

]]> Erreur : 0{,}25 n'est qu'un majorant, et la simulation montre
que la probabilité est bien plus petite.

]]> Il faut remplacer √n par n dans l'inégalité

]]> Erreur : la simulation ne remet pas l'inégalité en cause ; elle
montre seulement que la borne est large.

]]> La simulation contredit l'inégalité

]]> Erreur : l'inégalité fournit un majorant. Une probabilité plus
petite que la borne est conforme.

]]> Algorithmique et programmation — Q27 : Précision d'une estimation par Monte-Carlo Une estimation de π par Monte-Carlo avec n points donne des
résultats qui fluctuent d'une exécution à l'autre. Comment évolue
cette fluctuation quand on multiplie n par 100 ?

]]> Gagner une décimale de précision demande de multiplier le nombre de
points par 100 : la méthode de Monte-Carlo converge lentement.

]]> 1.0 0.0 0 true true abc Elle ne change pas

]]> Erreur : d'après la loi des grands nombres, la fréquence se
concentre autour de sa probabilité quand n grandit.

]]> Elle est environ divisée par 10

]]> Bonne réponse : l'écart type d'une fréquence est proportionnel à
\dfrac{1}{\sqrt{n}}, et √100 = 10.

]]> Elle disparaît complètement

]]> Erreur : tant que la simulation utilise le hasard, le résultat
fluctue, même pour un très grand n.

]]> Elle est environ divisée par 100

]]> Erreur : c'est la variance qui est divisée par 100. L'écart
type l'est par √100.

]]> Algorithmique et programmation — Q28 : Une somme alternée qui approche ln 2 Que calcule s(4) ?

`python def s(n): t = 0 for k in range(1, n + 1): t = t + (-1) ** (k + 1) / k return t`

]]> Ces sommes se rapprochent de \ln 2 \approx 0{,}693 quand n
grandit, mais lentement. Brouncker a proposé une autre écriture de
ln 2 qui converge plus vite.

]]> 1.0 0.0 0 true true abc 1 - ½ + ⅓ - ¼

]]> Bonne réponse : pour k impair, (-1)ᵏ⁺¹ = 1 ; pour k
pair, il vaut -1. On obtient \dfrac{7}{12} \approx 0{,}58.

]]> -1 + ½ - ⅓ + ¼

]]> Erreur : pour k = 1, (-1)ᵏ⁺¹ = (-1)² = 1 ; le premier
terme est positif.

]]> 1 - ½ + ⅓

]]> Erreur : range(1, n + 1) va jusqu'à k = 4 ; le terme
-¼ est ajouté.

]]> 1 + ½ + ⅓ + ¼

]]> Erreur : le facteur (-1)ᵏ⁺¹ alterne les signes des termes.

]]> Algorithmique et programmation — Q29 : Itérer une fonction continue On pose f(x) = √x + 2. Vers quelle valeur les nombres
renvoyés par iter(n) se rapprochent-ils quand n grandit ?

`python def iter(n): u = 0 for k in range(n): u = (u + 2) ** 0.5 return u`

]]> Pour uₙ₊₁ = f(uₙ) avec f continue, une limite finie \ell
vérifie f(\ell) = \ell. On obtient les valeurs 0, 1{,}414,
1{,}848, 1{,}962, …

]]> 1.0 0.0 0 true true abc √2

]]> Erreur : √2 est seulement u₁. Les termes suivants
continuent de croître.

]]> +∞

]]> Erreur : la suite est croissante mais majorée par 2, donc
elle converge.

]]> 2

]]> Bonne réponse : f est continue, donc la limite \ell vérifie
\ell = \sqrt{\ell + 2}, soit \ell^2 - \ell - 2 = 0 avec
\ell \geq 0 : \ell = 2.

]]> -1

]]> Erreur : -1 est l'autre solution de \ell^2 - \ell - 2 = 0,
mais une racine carrée est positive.

]]> Algorithmique et programmation — Q30 : Moyenne d'une liste de résultats simulés La liste R contient 10 000 résultats simulés d'une variable
aléatoire X. Que fournit sum(R) / len(R) ?

]]> Simuler un échantillon puis calculer sa moyenne permet d'estimer une
espérance inaccessible au calcul direct.

]]> 1.0 0.0 0 true true abc Une estimation de E(X)

]]> Bonne réponse : la moyenne d'un grand échantillon se rapproche
de l'espérance, d'après la loi des grands nombres.

]]> La valeur exacte de E(X)

]]> Erreur : la moyenne observée fluctue d'une simulation à l'autre.
Elle approche l'espérance sans l'égaler.

]]> Une estimation de la variance V(X)

]]> Erreur : la variance est la moyenne des carrés des écarts à la
moyenne, pas la moyenne des valeurs.

]]> La valeur la plus fréquente de X

]]> Erreur : la fonction additionne toutes les valeurs puis divise
par leur nombre : c'est une moyenne.

]]> Algorithmique et programmation — Q31 : Les carrés par une liste en compréhension Qu'affiche print([k**2 for k in range(1, 5)]) ?

]]> [expression for k in range(a, b)] construit la liste des valeurs
de l'expression pour k de a à b - 1.

]]> 1.0 0.0 0 true true abc [1, 4, 9, 16, 25]

]]> Erreur : la borne 5 est exclue.

]]> [1, 4, 9, 16]

]]> Bonne réponse : range(1, 5) donne 1, 2, 3, 4, dont on
prend les carrés.

]]> [2, 4, 6, 8]

]]> Erreur : k**2 est le carré, pas le double.

]]> [0, 1, 4, 9, 16]

]]> Erreur : range(1, 5) commence à 1, pas à 0.

]]> Algorithmique et programmation — Q32 : Une somme de termes par compréhension Que vaut, arrondi au centième, sum([1/k for k in range(1, 4)]) ?

]]> sum additionne les éléments d'une liste ; combinée à une
compréhension, elle calcule une somme de termes définis par une
formule.

]]> 1.0 0.0 0 true true abc 0.83, soit ½ + ⅓

]]> Erreur : le terme k = 1, qui vaut 1, fait partie de la
liste.

]]> 2.08, soit 1 + ½ + ⅓ + ¼

]]> Erreur : range(1, 4) s'arrête à 3.

]]> 1.83, soit 1 + ½ + ⅓

]]> Bonne réponse : la liste contient 1, 0{,}5 et 0{,}333\ldots,
de somme 1{,}833\ldots

]]> 6, la somme des entiers de 1 à 3

]]> Erreur : la liste contient les inverses des entiers.

]]> Algorithmique et programmation — Q33 : Compter les éléments positifs Avec L = [3, -1, 4, -2, 5], que vaut len([x for x in L if x > 0]) ?

]]> Filtrer par compréhension puis compter avec len : une façon
compacte de dénombrer.

]]> 1.0 0.0 0 true true abc [3, 4, 5], la liste filtrée

]]> Erreur : c'est la liste filtrée ; len en renvoie la longueur.

]]> 3, le nombre d'éléments positifs

]]> Bonne réponse : la compréhension garde 3, 4 et 5, et
len compte ces trois éléments.

]]> 12, la somme des éléments positifs

]]> Erreur : len compte, il n'additionne pas ; sum donnerait
12.

]]> 5, la longueur de L sans filtre

]]> Erreur : le filtre if x > 0 écarte les deux négatifs.

]]> Algorithmique et programmation — Q34 : Les premiers termes d'une suite rangés dans une liste Qu'affiche ce programme ?
`

python

u = 1

L = [u]

for k in range(3):

    u = 2 * u + 1

    L.append(u)

print(L)

]]> Pour conserver tous les termes d'une suite, on les ajoute un à un à
une liste avec append.

]]> 1.0 0.0 0 true true abc [3, 7, 15, 31]

]]> Erreur : u₀ est rangé dans la liste avant la boucle.

]]> [1, 3, 7]

]]> Erreur : range(3) ajoute trois termes après u₀, soit
quatre éléments.

]]> [1, 2, 4, 8]

]]> Erreur : la relation est 2u + 1, pas 2u.

]]> [1, 3, 7, 15]

]]> Bonne réponse : la liste contient u₀ = 1, puis les trois
termes suivants calculés par uₙ₊₁ = 2uₙ + 1.

]]> Algorithmique et programmation — Q35 : La position du maximum Avec L = [4, 9, 2, 9], que vaut L.index(max(L)) ?

]]> max donne la valeur, index sa première position : combinés, ils
localisent le maximum.

]]> 1.0 0.0 0 true true abc 3, l'indice de la dernière occurrence

]]> Erreur : index s'arrête à la première occurrence trouvée.

]]> 9, la valeur du maximum

]]> Erreur : index renvoie une position, pas une valeur.

]]> Une erreur, le maximum apparaissant plusieurs fois

]]> Erreur : index accepte les répétitions ; il renvoie la
première position.

]]> 1, l'indice de la première occurrence de 9

]]> Bonne réponse : max(L) vaut 9 et index renvoie la
position de sa première occurrence.

]]> Algorithmique et programmation — Q36 : Trier sans modifier la liste Qu'affiche ce programme ?
`

python

L = [5, 2, 8]

M = sorted(L)

print(L, M)

]]> sorted(L) renvoie une copie triée ; L.sort() trie la liste
elle-même et renvoie None.

]]> 1.0 0.0 0 true true abc Une erreur, sorted s'appliquant seulement aux nombres triés

]]> Erreur : sorted accepte toute liste de nombres.

]]> [5, 2, 8] [2, 5, 8], sorted renvoyant une copie triée

]]> Bonne réponse : sorted(L) construit une nouvelle liste triée
et laisse L intacte.

]]> [5, 2, 8] None, le tri ne renvoyant rien

]]> Erreur : L.sort() renvoie None, mais sorted(L) renvoie
la liste triée.

]]> [2, 5, 8] [2, 5, 8], les deux listes triées

]]> Erreur : c'est L.sort() qui trie L sur place.

]]> Algorithmique et programmation — Q37 : Somme des éléments d'indice pair Avec L = [3, 1, 4, 1, 5], que vaut sum(L[i] for i in range(0, len(L), 2)) ?

]]> Le troisième argument de range fixe le pas du parcours.

]]> 1.0 0.0 0 true true abc 6, la somme des indices pairs

]]> Erreur : on additionne L[i], pas i.

]]> 2, la somme des éléments d'indices 1 et 3

]]> Erreur : le parcours commence à l'indice 0.

]]> 12, la somme des éléments d'indices 0, 2 et 4

]]> Bonne réponse : range(0, 5, 2) parcourt 0, 2 et 4, et
la somme porte sur ces trois éléments.

]]> 14, la somme de tous les éléments

]]> Erreur : le pas 2 saute un élément sur deux.

]]> Algorithmique et programmation — Q38 : Compter les couples ordonnés Que vaut len([(i, j) for i in range(4) for j in range(4) if i < j]) ?

]]> Une double compréhension avec i < j énumère les paires, sans
ordre ni répétition.

]]> 1.0 0.0 0 true true abc 16, le nombre total de couples

]]> Erreur : la condition if i < j n'en garde qu'une partie.

]]> 6, le nombre de couples (i, j) avec i < j

]]> Bonne réponse : (0,1), (0,2), (0,3), (1,2), (1,3),
(2,3), soit \binom{4}{2} = 6.

]]> 4, une valeur par i

]]> Erreur : chaque i se combine avec plusieurs j.

]]> 12, les couples d'éléments distincts

]]> Erreur : i < j élimine aussi les couples avec i > j, pas
seulement i = j.

]]> Algorithmique et programmation — Q39 : Compter les changements de signe Qu'affiche ce programme ?
`

python

L = [-3, -1, 2, 5, -2]

c = 0

for i in range(len(L) - 1):

    if L[i] * L[i + 1] < 0:

        c = c + 1

print(c)

]]> Compter les changements de signe d'une liste de valeurs d'une
fonction localise les intervalles où elle s'annule.

]]> 1.0 0.0 0 true true abc 3, le nombre de valeurs négatives

]]> Erreur : le test porte sur un produit de voisins, pas sur le
signe d'une valeur.

]]> 2, le nombre de changements de signe entre voisins

]]> Bonne réponse : un produit négatif signale deux voisins de
signes contraires ; cela arrive entre -1 et 2, puis entre
5 et -2.

]]> 4, le nombre de paires de voisins

]]> Erreur : seules les paires de signes contraires comptent.

]]> 1, un seul passage du négatif au positif

]]> Erreur : le passage du positif au négatif compte aussi.

]]> Algorithmique et programmation — Q40 : Deux pas de la méthode d'Euler On applique la méthode d'Euler à y' = y avec y(0) = 1 et un
pas h = 0{,}5. Qu'affiche ce programme ?
`

python

y = 1

h = 0.5

for i in range(2):

    y = y + h * y

print(y)

]]> Pour y' = y, un pas d'Euler multiplie la valeur par 1 + h ; la
méthode approche \mathrm{e} quand h tend vers 0.

]]> 1.0 0.0 0 true true abc 2.25, soit 1{,}5^2

]]> Bonne réponse : chaque pas multiplie y par 1 + h = 1{,}5 ;
deux pas donnent 1{,}5^2.

]]> 1.5, un seul pas

]]> Erreur : range(2) fait deux tours.

]]> 2.0, soit 1 + 2 \times 0{,}5

]]> Erreur : le second pas utilise la valeur 1{,}5, pas 1.

]]> 2.718…, la valeur exacte \mathrm{e}

]]> Erreur : Euler donne une valeur approchée de y(1) =
\mathrm{e}, ici par défaut.

]]> Algorithmique et programmation — Q41 : Somme géométrique à un centième de sa limite Qu'affiche ce programme ?
`

python

s = 0

n = 0

while 2 - s > 0.01:

    s = s + 0.5 ** n

    n = n + 1

print(n)

]]> La somme 1 + 0{,}5 + \ldots + 0{,}5^{n-1} vaut 2 - 0{,}5^{n-1}
et converge vers 2.

]]> 1.0 0.0 0 true true abc 7, le dernier rang où l'écart dépasse 0{,}01

]]> Erreur : avec 7 termes l'écart vaut 0{,}5^6 \approx 0{,}016,
la boucle continue.

]]> 8, nombre de termes pour approcher 2 à 0{,}01 près

]]> Bonne réponse : après n termes, 2 - s = 0{,}5^{n-1} ; il
faut 0{,}5^{n-1} \leq 0{,}01, soit n - 1 ≥ 7.

]]> 100, l'inverse de la précision

]]> Erreur : la convergence géométrique demande bien moins de
termes.

]]> 2, la limite de la somme

]]> Erreur : le programme affiche le nombre de termes, pas la
limite.

]]> Algorithmique et programmation — Q42 : Simuler une variable binomiale Que renvoie l'appel binom(10, 0.5) ?
``python
from random import random

def binom(n, p):
s = 0
for i in range(n):
if random() < p:
s = s + 1
return s
``

]]> Une variable binomiale est une somme de variables de Bernoulli
indépendantes : la boucle les simule une à une.

]]> 1.0 0.0 0 true true abc 10, le nombre d'épreuves

]]> Erreur : s ne compte que les tours où random() < p.

]]> Un flottant entre 0 et 1, la fréquence des succès

]]> Erreur : la fonction renvoie s, pas s / n.

]]> Un entier entre 0 et 10, le nombre de succès simulés

]]> Bonne réponse : chaque tour simule une épreuve de probabilité
0{,}5 ; s compte les succès et suit la loi binomiale de
paramètres 10 et 0{,}5.

]]> Toujours 5, l'espérance de la loi

]]> Erreur : la valeur varie d'un appel à l'autre, 5 n'est que
la moyenne attendue.

]]> Algorithmique et programmation — Q43 : Compter les chemins de l'arbre avec comb Dans un schéma de Bernoulli à 6 épreuves, combien de chemins
comportent exactement 2 succès ? Quelle instruction le calcule ?

]]> Le coefficient binomial \binom{n}{k} compte les chemins à k
succès ; math.comb(n, k) le calcule.

]]> 1.0 0.0 0 true true abc 720, donné par factorial(6)

]]> Erreur : 6! compte les ordres de six objets distincts.

]]> 15, donné par comb(6, 2)

]]> Bonne réponse : \binom{6}{2} = 15 chemins, calculé par
comb du module math.

]]> 12, donné par 6 * 2

]]> Erreur : le produit 6 × 2 ne compte aucun chemin.

]]> 30, donné par 6 * 5

]]> Erreur : 6 × 5 compte deux fois chaque chemin, l'ordre
des deux succès n'important pas.

]]> Algorithmique et programmation — Q44 : Un « au moins » par l'événement contraire X suit la loi binomiale de paramètres 10 et 0{,}2. Que
calcule ce programme ?
``python
from math import comb

def p(n, k, q):
return comb(n, k) q k (1 - q) ** (n - k)

s = 0
for k in range(3):
s = s + p(10, k, 0.2)
print(1 - s)
``

]]> P(X ≥ k) se calcule par 1 - P(X ≤ k - 1), la somme
portant sur k termes.

]]> 1.0 0.0 0 true true abc P(X \geq 3) \approx 0{,}322

]]> Bonne réponse : la boucle somme P(X = 0), P(X = 1) et
P(X = 2), soit P(X ≤ 2) ; le complément est
P(X ≥ 3).

]]> P(X > 3) \approx 0{,}121

]]> Erreur : range(3) s'arrête à k = 2, donc k = 3 fait
partie du complément.

]]> P(X \leq 2) \approx 0{,}678

]]> Erreur : c'est la valeur de s, pas de 1 - s.

]]> P(X = 3) \approx 0{,}201

]]> Erreur : le programme somme plusieurs probabilités avant de
passer au complément.

]]> Algorithmique et programmation — Q45 : Part des échantillons hors de l'intervalle Qu'affiche ce programme ?
``python
from random import random

def frequence(n, p):
c = 0
for i in range(n):
if random() < p:
c = c + 1
return c / n

nb = 0
for j in range(1000):
if abs(frequence(100, 0.5) - 0.5) > 0.1:
nb = nb + 1
print(nb / 1000)
``

]]> La proportion d'échantillons dont la fréquence s'écarte de p de
plus de \frac{1}{\sqrt{n}} est faible, de l'ordre de 5\ %.

]]> 1.0 0.0 0 true true abc Un nombre inférieur à 0.1, une petite minorité d'échantillons

]]> Bonne réponse : pour n = 100, \frac{1}{\sqrt{n}} = 0{,}1 ;
la fréquence sort de [0{,}4 ; 0{,}6] dans environ 5\ %
des échantillons.

]]> 0.0, la fréquence restant toujours dans l'intervalle

]]> Erreur : l'intervalle n'est pas une certitude, quelques
échantillons en sortent.

]]> Un nombre proche de 0.95, la plupart des échantillons

]]> Erreur : le programme compte les échantillons qui sortent de
l'intervalle, pas ceux qui y restent.

]]> Un nombre proche de 0.5, la moitié des échantillons

]]> Erreur : la plupart des fréquences restent à moins de
\frac{1}{\sqrt{n}} de p.

]]>