$course$/QCM de maths/Première spécialité/Algorithmique et listes Notion de liste : générer une liste en extension, par ajouts
successifs ou en compréhension, manipuler ses éléments et leurs
indices, la parcourir. Algorithmes du programme : termes, sommes et
seuils d'une suite, factorielle, suite de Fibonacci, sécantes,
méthode de Newton, méthode d'Euler, Monte-Carlo, espérance.

]]> Algorithmique et listes — Q01 : Le premier élément d'une liste On pose L = [4, 9, 2, 7]. Que vaut L[1] ?

]]> Dans une liste de n éléments, les indices vont de 0 à n - 1 :
L[0] est le premier élément, L[n - 1] le dernier.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : L[1] désigne l'élément d'indice 1, pas le nombre
1.

]]> 9

]]> Bonne réponse : les indices commencent à 0. L[0] vaut 4 et
L[1] vaut 9.

]]> 4

]]> Erreur : 4 est L[0]. Le premier élément porte l'indice 0.

]]> 2

]]> Erreur : 2 est L[2], le troisième élément de la liste.

]]> Algorithmique et listes — Q02 : Longueur et dernier élément On pose L = [3, 8, 5, 1, 6]. Quelle expression désigne le dernier
élément de L ?

]]> len(L) renvoie le nombre d'éléments. Le dernier élément est
L[len(L) - 1].

]]> 1.0 0.0 0 true true abc L[len(L)]

]]> Erreur : l'indice 5 n'existe pas, ce qui provoque une erreur
d'exécution. Les indices s'arrêtent à 4.

]]> len(L)

]]> Erreur : len(L) est le nombre d'éléments, ici 5, pas le
dernier élément.

]]> L[len(L) - 2]

]]> Erreur : l'indice 5 - 2 = 3 désigne l'avant-dernier élément, 1.

]]> L[len(L) - 1]

]]> Bonne réponse : len(L) vaut 5, et le dernier indice est
5 - 1 = 4 : L[4] vaut 6.

]]> Algorithmique et listes — Q03 : Ajouter un élément Que contient L après ces instructions ?

`python
L = [5, 2]
L.append(8)
L.append(1)
`

]]> L.append(x) ajoute x à la fin de L. Partir de [] puis
ajouter dans une boucle, c'est générer une liste par ajouts
successifs.

]]> 1.0 0.0 0 true true abc [5, 2, 9]

]]> Erreur : les éléments ajoutés ne s'additionnent pas. Chacun
devient un nouvel élément.

]]> [5, 2, 8, 1]

]]> Bonne réponse : append ajoute l'élément à la fin de la liste,
dans l'ordre des instructions.

]]> [8, 1, 5, 2]

]]> Erreur : append ajoute en fin de liste, pas au début.

]]> [1, 2, 5, 8]

]]> Erreur : une liste ne se trie pas d'elle-même. L'ordre des
ajouts est conservé.

]]> Algorithmique et listes — Q04 : Une liste en compréhension Que contient la liste [k ** 2 for k in range(5)] ?

]]> [expression for k in range(n)] construit la liste des valeurs de
l'expression pour k allant de 0 à n - 1.

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

]]> Bonne réponse : k parcourt 0, 1, 2, 3, 4, et la
liste contient leurs carrés.

]]> [0, 1, 2, 3, 4]

]]> Erreur : ce sont les valeurs de k, avant d'appliquer
l'expression k ** 2.

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

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

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

]]> Erreur : range(5) commence à 0 et s'arrête à 4. Le carré
de 5 n'y figure pas.

]]> Algorithmique et listes — Q05 : Une compréhension avec condition Que contient la liste [n for n in range(1, 20) if n % 4 == 0] ?

]]> La condition placée après if filtre les valeurs : c'est la
traduction en Python d'un ensemble défini par une propriété,
\{n \in \{1, \ldots, 19\} \mid 4 \text{ divise } n\}.

]]> 1.0 0.0 0 true true abc [0, 4, 8, 12, 16]

]]> Erreur : le parcours commence à 1, donc 0 n'est pas examiné.

]]> [4, 8, 12, 16, 20]

]]> Erreur : range(1, 20) s'arrête à 19. L'entier 20 n'est pas
examiné.

]]> [4, 8, 12, 16]

]]> Bonne réponse : on garde les entiers de 1 à 19 dont le reste
dans la division par 4 est nul, c'est-à-dire les multiples de
4.

]]> [1, 2, 3, 4]

]]> Erreur : la condition filtre les entiers, elle ne compte pas les
multiples.

]]> Algorithmique et listes — Q06 : Modifier un élément par son indice Que contient L après ces instructions ?

`python
L = [10, 20, 30, 40]
L[2] = L[0] + L[3]
`

]]> L[i] = valeur remplace l'élément d'indice i. La longueur de la
liste ne change pas.

]]> 1.0 0.0 0 true true abc [10, 20, 30, 40, 50]

]]> Erreur : une affectation L[2] = … remplace un élément, elle
n'ajoute rien à la liste.

]]> [10, 20, 60, 40]

]]> Erreur : L[3] vaut 40 et non 30 : les indices commencent
à 0.

]]> [10, 50, 30, 40]

]]> Erreur : l'élément d'indice 2 est le troisième. C'est 30 qui
est remplacé, pas 20.

]]> [10, 20, 50, 40]

]]> Bonne réponse : L[0] + L[3] vaut 10 + 40 = 50, et cette
valeur remplace l'élément d'indice 2, qui valait 30.

]]> Algorithmique et listes — Q07 : Supprimer un élément Que contient L après ces instructions ?

`python
L = [7, 3, 9, 3]
L.remove(3)
`

]]> L.remove(x) retire la première occurrence de la valeur x ;
del L[i] retire l'élément d'indice i.

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

]]> Erreur : remove(3) supprime la valeur 3, pas l'élément
d'indice 3 ni celui d'indice 2.

]]> [7, 9, 3]

]]> Bonne réponse : remove(3) supprime la première occurrence
de la valeur 3 seulement.

]]> [7, 3, 9]

]]> Erreur : c'est la première occurrence de 3 qui disparaît, pas
la dernière.

]]> [7, 9]

]]> Erreur : remove ne supprime qu'une occurrence, la première
rencontrée.

]]> Algorithmique et listes — Q08 : Générer une liste par ajouts successifs Que contient L à la fin de ce programme ?

`python
L = []
for k in range(1, 5):
L.append(3 * k - 1)
`

]]> Le même résultat s'obtient en compréhension :
[3 * k - 1 for k in range(1, 5)].

]]> 1.0 0.0 0 true true abc [2, 5, 8, 11]

]]> Bonne réponse : pour k de 1 à 4, on ajoute 3k - 1, soit
2, 5, 8 et 11.

]]> [-1, 2, 5, 8]

]]> Erreur : le parcours commence à k = 1 et non à k = 0.

]]> [11]

]]> Erreur : append ajoute un élément à chaque tour, sans effacer
les précédents.

]]> [2, 5, 8, 11, 14]

]]> Erreur : range(1, 5) s'arrête à 4. La valeur k = 5 n'est
pas prise.

]]> Algorithmique et listes — Q09 : Itérer sur les éléments Qu'affiche ce programme ?

`python
s = 0
for x in [4, 1, 6]:
s = s + x
print(s)
`

]]> for x in L: donne à x chacun des éléments de L, dans l'ordre.
On parle d'itération sur les éléments.

]]> 1.0 0.0 0 true true abc 3, soit 0 + 1 + 2

]]> Erreur : for x in L parcourt les éléments de la liste, pas
ses indices.

]]> 24

]]> Erreur : les éléments sont additionnés, pas multipliés. La
variable s part de 0 et reçoit s + x.

]]> 6

]]> Erreur : s accumule toutes les valeurs, elle ne garde pas
seulement la dernière.

]]> 11

]]> Bonne réponse : x prend successivement les valeurs 4, 1 et
6, que l'on additionne.

]]> Algorithmique et listes — Q10 : Parcourir par les indices Qu'affiche ce programme ?

`python
L = [5, 8, 2, 9]
for i in range(len(L)):
if L[i] > 6:
print(i)
`

]]> for i in range(len(L)) parcourt les indices ; on accède à
l'élément par L[i]. Ce parcours sert quand la position compte.

]]> 1.0 0.0 0 true true abc 8 puis 9

]]> Erreur : le programme affiche i, l'indice, et non L[i],
l'élément.

]]> 2 puis 4

]]> Erreur : ce seraient les positions en comptant à partir de 1.
Les indices Python commencent à 0.

]]> 1 puis 3

]]> Bonne réponse : les éléments supérieurs à 6 sont 8 et 9,
d'indices 1 et 3. Le programme affiche les indices.

]]> 2

]]> Erreur : 2 est le nombre d'éléments supérieurs à 6, mais le
programme affiche chaque indice trouvé.

]]> Algorithmique et listes — Q11 : Chercher le maximum La fonction suivante doit renvoyer le plus grand élément d'une liste
non vide. Quelle ligne compléter ?

`python
def maximum(L):
m = L[0]
for x in L:
if x > m:
...
return m
`

]]> Recherche d'un maximum : on part du premier élément, on parcourt la
liste et on met à jour la valeur retenue à chaque élément plus grand.

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

]]> Erreur : l'affectation est à l'envers. m ne change jamais et
reste égal à L[0].

]]> m = m + x

]]> Erreur : m deviendrait une somme partielle, pas un maximum.

]]> return x

]]> Erreur : la fonction s'arrêterait au premier élément plus grand
que L[0], sans examiner la suite.

]]> m = x

]]> Bonne réponse : dès qu'un élément dépasse le maximum provisoire,
il le remplace.

]]> Algorithmique et listes — Q12 : Compter des occurrences Que renvoie compte([1, 3, 1, 1, 2], 1) ?

`python
def compte(L, v):
c = 0
for x in L:
if x == v:
c = c + 1
return c / len(L)
`

]]> Cette fonction calcule la fréquence d'une valeur dans une série. Le
même principe sert à étudier la fréquence des lettres d'un texte.

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

]]> Erreur : le compteur augmente à chaque occurrence, pas une seule
fois.

]]> 0{,}6

]]> Bonne réponse : la valeur 1 apparaît 3 fois sur 5
éléments. La fonction renvoie la fréquence ⅗.

]]> 3

]]> Erreur : 3 est l'effectif. La division par len(L) le
transforme en fréquence.

]]> 1{,}6

]]> Erreur : la fonction compte les éléments égaux à v, elle
n'additionne pas les valeurs.

]]> Algorithmique et listes — Q13 : Moyenne d'une série avec effectifs Les listes V et E contiennent les valeurs d'une série et leurs
effectifs. Que renvoie moy([2, 5, 10], [3, 1, 1]) ?

`python
def moy(V, E):
s = 0
for i in range(len(V)):
s = s + V[i] * E[i]
return s / sum(E)
`

]]> Moyenne pondérée : \bar{x} = \dfrac{\sum n_i x_i}{\sum n_i}. Le
parcours par indices permet d'associer chaque valeur à son effectif.

]]> 1.0 0.0 0 true true abc 7

]]> Erreur : la somme pondérée est divisée par l'effectif total,
sum(E), et non par le nombre de valeurs distinctes.

]]> 4{,}2

]]> Bonne réponse : 2 × 3 + 5 × 1 + 10 × 1 = 21,
divisé par l'effectif total 5.

]]> 5{,}\overline{6}

]]> Erreur : c'est la moyenne des trois valeurs sans tenir compte
des effectifs.

]]> 21

]]> Erreur : 21 est la somme pondérée. Il reste à la diviser par
l'effectif total.

]]> Algorithmique et listes — Q14 : Espérance d'une loi donnée par deux listes Une variable aléatoire prend les valeurs de la liste X avec les
probabilités de la liste P. Quelle fonction renvoie son
espérance ?

]]> L'espérance est la somme des produits valeur × probabilité. Les
probabilités ont une somme égale à 1, d'où l'absence de division.

]]> 1.0 0.0 0 true true abc `python
def esperance(X, P):
return sum([X[i] * P[i] for i in range(len(X))])
`

]]> Bonne réponse : E = ∑ xᵢ pᵢ. La liste en compréhension
contient les produits, sum les additionne.

]]> `python
def esperance(X, P):
return sum(X) / len(X)
`

]]> Erreur : c'est la moyenne des valeurs, qui ignore les
probabilités. Elle ne coïncide avec l'espérance que dans le cas
équiprobable.

]]> `python
def esperance(X, P):
return sum(X) * sum(P)
`

]]> Erreur : sum(P) vaut 1, donc cette fonction renvoie la somme
des valeurs, sans pondération.

]]> `python
def esperance(X, P):
return sum([X[i] * P[i] for i in range(len(X))]) / len(X)
`

]]> Erreur : la somme des xᵢ pᵢ est déjà l'espérance ; la
division par le nombre de valeurs est de trop.

]]> Algorithmique et listes — Q15 : Calculer un terme par une boucle La suite (uₙ) vérifie u₀ = 3 et uₙ₊₁ = uₙ + 2.
Que renvoie terme(3) ?

`python
def terme(n):
u = 3
for i in range(n):
u = u + (2)
return u
`

]]> Pour calculer uₙ à partir d'une relation de récurrence, on
initialise avec u₀ et l'on applique n fois la relation.

]]> 1.0 0.0 0 true true abc 9

]]> Bonne réponse : la boucle fait 3 tours et passe de u₀ à
u₃.

]]> 24

]]> Erreur : la suite est arithmétique. On ajoute la raison à chaque
tour, on ne multiplie pas.

]]> 7

]]> Erreur : 7 est u_{3 - 1}. La boucle fait bien 3
tours.

]]> 11

]]> Erreur : un tour de trop. range(3) produit 3 valeurs de
i.

]]> Algorithmique et listes — Q16 : Liste des premiers termes Que renvoie termes(4) ?

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

]]> Pour obtenir la liste [u₀, …, uₙ], on range u₀ dans la
liste, puis on ajoute chaque nouveau terme dans la boucle.

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

]]> Erreur : la liste est initialisée avec u₀ avant la boucle, il
faut le compter.

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

]]> Erreur : la boucle fait 4 tours et ajoute 4 termes à u₀ :
la liste en contient 5.

]]> [1, 3, 5, 7, 9]

]]> Erreur : chaque terme est le double du précédent augmenté de
1 ; ajouter 2 à chaque fois donnerait une suite
arithmétique.

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

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

]]> Algorithmique et listes — Q17 : Somme des termes d'une suite Que renvoie somme(3) ?

`python
def somme(n):
u = 2
s = 0
for k in range(n + 1):
s = s + u
u = 3 * u
return s
`

]]> La formule donne le même résultat :
2 × 3⁴ - 1/3 - 1 = 80. L'ordre des deux
instructions dans la boucle décide des termes additionnés.

]]> 1.0 0.0 0 true true abc 80

]]> Bonne réponse : on additionne u₀ à u₃ de la suite
géométrique de premier terme 2 et de raison 3 :
2 + 6 + 18 + 54 = 80.

]]> 54

]]> Erreur : 54 est le terme u₃. La fonction renvoie la somme
des termes.

]]> 26

]]> Erreur : range(n + 1) fait 4 tours pour n = 3, donc quatre
termes sont additionnés, pas trois.

]]> 242

]]> Erreur : le terme 162 est calculé au dernier tour, mais après
l'ajout, donc il n'entre pas dans la somme.

]]> Algorithmique et listes — Q18 : Un algorithme de seuil décroissant Une population de 5 000 individus diminue de 10\ % par an. Que
renvoie la fonction suivante ?

`python
def seuil():
p = 5000
n = 0
while p >= 2500:
p = 0.9 * p
n = n + 1
return n
`

]]> Algorithme de seuil : la boucle while tourne tant que le seuil
n'est pas franchi. Ici 0{,}9^6 \approx 0{,}53 et
0{,}9^7 \approx 0{,}48, d'où n = 7.

]]> 1.0 0.0 0 true true abc La population restante après 2 500 années

]]> Erreur : 2 500 est un seuil de population, et la fonction
renvoie n, un nombre d'années.

]]> La dernière année où la population dépasse 2 500

]]> Erreur : à la sortie de la boucle, la condition p >= 2500 est
fausse : l'année renvoyée est la première sous le seuil.

]]> Le premier rang où la population passe sous 2 500

]]> Bonne réponse : la boucle s'arrête dès que p < 2 500, et n
compte les années écoulées. On trouve n = 7.

]]> Le nombre d'individus perdus chaque année

]]> Erreur : la perte annuelle n'est pas calculée. n compte les
tours de boucle, donc les années.

]]> Algorithmique et listes — Q19 : Calcul d'une factorielle On note n! = 1 × 2 × ⋯ × n. Quelle fonction
renvoie n! pour un entier n ≥ 1 ?

]]> Accumulateur de produit : initialisation à 1, multiplication à
chaque tour. Pour une somme, on initialise à 0 et l'on ajoute.

]]> 1.0 0.0 0 true true abc `python
def fact(n):
p = 1
for k in range(n):
p = p * k
return p
`

]]> Erreur : range(n) commence à 0, donc le produit vaut 0 dès
le premier tour.

]]> `python
def fact(n):
p = 0
for k in range(1, n + 1):
p = p * k
return p
`

]]> Erreur : un produit initialisé à 0 reste nul. Le produit vide
vaut 1.

]]> `python
def fact(n):
p = 1
for k in range(1, n + 1):
p = p * k
return p
`

]]> Bonne réponse : le produit démarre à 1 et k parcourt les
entiers de 1 à n.

]]> `python
def fact(n):
p = 1
for k in range(1, n + 1):
p = p + k
return p
`

]]> Erreur : cette fonction calcule une somme, 1 + 1 + 2 + ⋯ + n, et non un produit.

]]> Algorithmique et listes — Q20 : La suite de Fibonacci Que renvoie fibo(7) ?

`python
def fibo(n):
L = [1, 1]
while len(L) < n:
L.append(L[-1] + L[-2])
return L

On rappelle que L[-1] et L[-2] désignent le dernier et
l'avant-dernier élément de L`.

]]> Suite de Fibonacci : F₀ = F₁ = 1 et Fₙ₊₂ = Fₙ₊₁ + Fₙ.
Elle modélise le problème des lapins posé par Fibonacci.

]]> 1.0 0.0 0 true true abc [1, 1, 2, 4, 8, 16, 32]

]]> Erreur : chaque terme est la somme des deux derniers, pas le
double du dernier.

]]> [1, 1, 2, 3, 5, 8, 13, 21]

]]> Erreur : la condition len(L) < 7 devient fausse dès que la
liste compte 7 éléments. Aucun huitième terme n'est ajouté.

]]> [1, 1, 2, 3, 5, 8, 13]

]]> Bonne réponse : chaque nouveau terme est la somme des deux
précédents, et la boucle s'arrête quand la liste contient 7
éléments.

]]> [1, 2, 3, 4, 5, 6, 7]

]]> Erreur : on ajoute la somme des deux derniers termes, pas le
terme précédent augmenté de 1.

]]> Algorithmique et listes — Q21 : Une suite de Syracuse On part de l'entier 6 et l'on applique la règle suivante : un
entier pair est divisé par 2, un entier impair est remplacé par
son triple augmenté de 1. Que renvoie syracuse(6) ?

`python
def syracuse(n):
L = [n]
while n != 1:
if n % 2 == 0:
n = n // 2
else:
n = 3 * n + 1
L.append(n)
return L
`

]]> On observe sur les exemples que la suite finit toujours par
atteindre 1, mais personne n'a jamais su le démontrer : c'est la
conjecture de Syracuse.

]]> 1.0 0.0 0 true true abc [6, 3, 9, 27, 82, 41]

]]> Erreur : un entier impair est remplacé par 3n + 1 : 3 donne
10, pas 9.

]]> [6, 3, 10, 5, 16, 8, 4, 2, 1]

]]> Bonne réponse : 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1, et la boucle s'arrête quand n vaut 1.

]]> [6, 3, 10, 5, 16, 8, 4, 2]

]]> Erreur : la valeur 1 est ajoutée à la liste avant que la
condition n != 1 ne soit testée à nouveau.

]]> [3, 10, 5, 16, 8, 4, 2, 1]

]]> Erreur : la liste est initialisée avec la valeur de départ 6.

]]> Algorithmique et listes — Q22 : Les pentes des sécantes Que renvoie pentes(1) pour f(x) = x² ?

``python
def f(x):
return x ** 2

def pentes(a):
return [(f(a + h) - f(a)) / h for h in [1, 0.1, 0.01]]
``

]]> La pente de la sécante entre les points d'abscisses a et a + h
est f(a + h) - f(a)/h. Quand h se rapproche de 0,
elle se rapproche du nombre dérivé f'(a).

]]> 1.0 0.0 0 true true abc [1, 0.1, 0.01]

]]> Erreur : ce sont les valeurs du pas h, pas les pentes des
sécantes.

]]> [4, 1.21, 1.0201] environ

]]> Erreur : ce sont les images f(1 + h), pas les taux de
variation.

]]> [2, 2, 2]

]]> Erreur : 2 est la limite des pentes, le nombre dérivé. Les
pentes des sécantes en diffèrent de h.

]]> [3.0, 2.1, 2.01] environ

]]> Bonne réponse : le taux de variation de x² entre 1 et
1 + h vaut 2 + h. Ces pentes se rapprochent de
f'(1) = 2.

]]> Algorithmique et listes — Q23 : Une étape de la méthode de Newton La méthode de Newton approche une solution de f(x) = 0 en
remplaçant x par l'abscisse du point où la tangente en x coupe
l'axe des abscisses. Pour f(x) = x² - 2 et x = 1, quelle est la
nouvelle valeur ?

]]> Une étape de Newton remplace x par x - f(x)/f'(x). Pour
x² - 2, les valeurs 1, 1{,}5, 1{,}41\overline{6}…
s'approchent très vite de √2.

]]> 1.0 0.0 0 true true abc 2

]]> Erreur : la tangente en 1 a pour pente f'(1) = 2, pas 1.
On divise f(1) par cette pente.

]]> √2

]]> Erreur : √2 est la solution cherchée. Une étape de la
méthode n'en donne qu'une valeur approchée.

]]> 1{,}5

]]> Bonne réponse : la tangente en 1 a pour équation
y = f'(1)(x - 1) + f(1) = 2(x - 1) - 1 ; elle coupe l'axe pour
x = 1{,}5.

]]> 0{,}5

]]> Erreur de signe : la nouvelle valeur est
x - f(x)/f'(x) = 1 - -1/2.

]]> Algorithmique et listes — Q24 : Programmer la méthode de Newton On définit f et sa dérivée df. Quelle ligne compléter pour
programmer la méthode de Newton ?

`python
def newton(x, n):
for i in range(n):
...
return x
`

]]> La tangente en xₙ a pour équation
y = f'(xₙ)(t - xₙ) + f(xₙ) ; elle s'annule pour
t = xₙ - f(xₙ)/f'(xₙ), lorsque f'(xₙ) ≠ 0.

]]> 1.0 0.0 0 true true abc x = x + f(x) / df(x)

]]> Erreur de signe : la tangente coupe l'axe en
x - f(x)/f'(x).

]]> x = x - f(x) / df(x)

]]> Bonne réponse : c'est l'abscisse du point d'intersection de la
tangente en x avec l'axe des abscisses.

]]> x = x - df(x) / f(x)

]]> Erreur : le quotient est renversé. On divise f(x) par la
pente f'(x).

]]> x = f(x) / df(x)

]]> Erreur : il manque le point de départ x. On corrige la valeur
actuelle, on ne la remplace pas par le quotient.

]]> Algorithmique et listes — Q25 : La méthode d'Euler pour l'exponentielle L'exponentielle vérifie f' = f et f(0) = 1. La méthode d'Euler
de pas h remplace f(x + h) par l'approximation affine
f(x) + h f'(x). Avec h = 0{,}5, quelle valeur approchée de
f(1) obtient-on en deux pas ?

]]> Pour l'exponentielle, un pas d'Euler donne
f(x + h) ≈ (1 + h) f(x). En n pas de longueur
1/n, on obtient (1 + 1/n)ⁿ, qui
se rapproche de e quand n grandit.

]]> 1.0 0.0 0 true true abc 2

]]> Erreur : 1 + 0{,}5 + 0{,}5 ajoute deux fois le même
accroissement, alors que la pente change : au second pas, elle
vaut 1{,}5.

]]> 2{,}25

]]> Bonne réponse : chaque pas multiplie par 1 + h = 1{,}5 :
f(0{,}5) \approx 1{,}5 puis f(1) \approx 1{,}5^2 = 2{,}25.

]]> e \approx 2{,}718

]]> Erreur : c'est la valeur exacte. La méthode d'Euler n'en donne
qu'une approximation, d'autant meilleure que le pas est petit.

]]> 1{,}5

]]> Erreur : 1{,}5 approche f(0{,}5). Il faut un second pas pour
atteindre x = 1.

]]> Algorithmique et listes — Q26 : Approcher le nombre e On calcule (1 + 1/n)ⁿ pour n = 10, 100,
1 000 et on obtient environ 2{,}594, 2{,}705 et 2{,}717. Que
suggèrent ces valeurs ?

]]> Le programme propose d'approcher e à l'aide de la suite
((1 + 1/n)ⁿ), lien direct avec la
méthode d'Euler appliquée à l'exponentielle.

]]> 1.0 0.0 0 true true abc Elles se rapprochent de e

]]> Bonne réponse : ces valeurs s'approchent de
e \approx 2{,}718 à mesure que n grandit.

]]> Elles augmentent sans limite, comme n

]]> Erreur : les écarts entre valeurs successives diminuent
nettement : rien ne suggère une croissance sans limite.

]]> Elles sont toutes égales à e

]]> Erreur : ce sont des valeurs approchées, distinctes et
croissantes, qui se rapprochent de e sans l'atteindre.

]]> Elles se rapprochent de 1, car 1 + 1/n tend vers 1

]]> Erreur : l'exposant n grandit en même temps. Les valeurs
calculées augmentent et s'éloignent de 1.

]]> Algorithmique et listes — Q27 : Estimer pi par Monte-Carlo Le module random est importé. Que renvoie estime(100000),
environ ?

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

]]> Méthode de Monte-Carlo : on tire des points au hasard dans le carré
[0 ; 1] × [0 ; 1] ; la fréquence des points sous l'arc
de cercle approche l'aire du quart de disque, π/4.

]]> 1.0 0.0 0 true true abc Une valeur proche de π

]]> Bonne réponse : le quart de disque de rayon 1 occupe une
proportion π/4 du carré unité. La fréquence
multipliée par 4 approche π.

]]> Exactement π

]]> Erreur : le résultat dépend du hasard. Il fluctue autour de
π et varie d'un appel à l'autre.

]]> Une valeur proche de π/4

]]> Erreur : c/n approche π/4, mais la
fonction multiplie cette fréquence par 4.

]]> Une valeur proche de 1

]]> Erreur : les points ne tombent pas tous dans le quart de disque :
ceux proches du coin (1 ; 1) en sortent.

]]> Algorithmique et listes — Q28 : Aire sous la parabole par Monte-Carlo Pour estimer l'aire sous la courbe de x ↦ x² entre 0 et
1, on tire des points au hasard dans le carré unité. Quelle
condition compte les points situés sous la courbe ?

`python
x = random.random()
y = random.random()
if ...:
c = c + 1
`

]]> La fréquence des points sous la courbe approche l'aire cherchée,
qui vaut ⅓ ; en terminale, le calcul intégral confirme
cette valeur.

]]> 1.0 0.0 0 true true abc y >= x ** 2

]]> Erreur : cette condition compte les points au-dessus de la
courbe. Leur fréquence approche 1 moins l'aire cherchée.

]]> x 2 + y 2 <= 1

]]> Erreur : cette condition caractérise le quart de disque, qui
sert à estimer π.

]]> x <= y ** 2

]]> Erreur : les rôles de x et de y sont échangés. On compare
l'ordonnée du point à l'image de son abscisse.

]]> y <= x ** 2

]]> Bonne réponse : le point (x ; y) est sous la courbe lorsque
son ordonnée ne dépasse pas l'image x².

]]> Algorithmique et listes — Q29 : La méthode d'Archimède Pour approcher π, Archimède inscrit dans un cercle de rayon 1
des polygones réguliers dont il double le nombre de côtés. Que
devient le demi-périmètre de ces polygones ?

]]> En encadrant le cercle entre polygones inscrits et circonscrits à
96 côtés, Archimède obtient
3 + 10/71 < π < 3 + ⅐.

]]> 1.0 0.0 0 true true abc Il reste égal à 3 quel que soit le nombre de côtés

]]> Erreur : 3 est le demi-périmètre de l'hexagone inscrit. Il
augmente quand on double le nombre de côtés.

]]> Il se rapproche de π en restant supérieur à π

]]> Erreur : ce serait le cas de polygones circonscrits, qui
entourent le cercle.

]]> Il augmente sans limite avec le nombre de côtés

]]> Erreur : le polygone reste à l'intérieur du cercle, donc son
périmètre ne dépasse jamais 2π.

]]> Il se rapproche de π en restant inférieur à π

]]> Bonne réponse : un polygone inscrit a un périmètre plus petit que
celui du cercle, 2π, et s'en rapproche quand le nombre de
côtés augmente.

]]> Algorithmique et listes — Q30 : Moyenne simulée d'un gain Le module random est importé. Un jeu fait gagner 10 euros avec
probabilité 0{,}2 et perdre 2 euros sinon. Autour de quelle
valeur la fonction suivante renvoie-t-elle ses résultats pour
n = 100000 ?

`python
def gain_moyen(n):
s = 0
for i in range(n):
if random.random() < 0.2:
s = s + 10
else:
s = s - 2
return s / n
`

]]> Sur un grand nombre de parties, la moyenne des gains simulés se
rapproche de l'espérance de la variable aléatoire.

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

]]> Bonne réponse : la moyenne des gains simulés est proche de
l'espérance 10 \times 0{,}2 - 2 \times 0{,}8 = 0{,}4.

]]> 4

]]> Erreur : la moyenne de 10 et de -2 ignore les probabilités.
Le gain de 10 euros n'arrive qu'une fois sur cinq.

]]> 1{,}6

]]> Erreur : 2 \times 0{,}8 = 1{,}6 est la perte moyenne. Il faut
la retrancher du gain moyen 10 \times 0{,}2 = 2.

]]> 0{,}2

]]> Erreur : 0{,}2 est la probabilité de gagner, pas le gain
moyen.

]]> Algorithmique et listes — Q31 : Somme des éléments d'une liste par parcours Qu'affiche ce programme ?
`python
L = [4, 7, 1]
s = 0
for x in L:
s = s + x
print(s)
`

]]> Parcours par éléments avec un accumulateur : le schéma de base de
la somme d'une liste.

]]> 1.0 0.0 0 true true abc 12

]]> Bonne réponse : la boucle ajoute chaque élément à s, qui
finit par contenir la somme 12.

]]> 0

]]> Erreur : s est modifié à chaque tour, il ne reste pas à 0.

]]> 3

]]> Erreur : 3 est le nombre d'éléments.

]]> 7

]]> Erreur : 7 est le plus grand élément, pas la somme.

]]> Algorithmique et listes — Q32 : Minimum d'une liste par parcours Qu'affiche ce programme ?
`python
L = [5, 2, 8, 3]
m = L[0]
for x in L:
if x < m:
m = x
print(m)
`

]]> Initialiser m au premier élément puis comparer chaque élément :
le minimum sans fonction prédéfinie.

]]> 1.0 0.0 0 true true abc 0

]]> Erreur : m est initialisé à L[0], pas à 0.

]]> 5

]]> Erreur : 5 n'est que la valeur initiale de m.

]]> 2

]]> Bonne réponse : m est remplacé chaque fois qu'un élément plus
petit apparaît ; à la fin, il contient le minimum 2.

]]> 8

]]> Erreur : le test x < m cherche le plus petit ; le maximum
demanderait x > m.

]]> Algorithmique et listes — Q33 : Compter les éléments au-dessus d'un seuil Qu'affiche ce programme ?
`python
notes = [12, 7, 15, 9, 20]
c = 0
for n in notes:
if n >= 10:
c = c + 1
print(c)
`

]]> Compteur conditionnel : incrémenter seulement quand le test est
vrai.

]]> 1.0 0.0 0 true true abc 3

]]> Bonne réponse : le compteur augmente pour chaque note
supérieure ou égale à 10 ; il y en a 3.

]]> 5

]]> Erreur : 5 est le nombre total de notes, sans la condition.

]]> 47

]]> Erreur : 47 est la somme des notes ; le programme compte, il
n'additionne pas les valeurs.

]]> 10

]]> Erreur : 10 est le seuil, pas le résultat.

]]> Algorithmique et listes — Q34 : L'indice du maximum en cas d'égalité Qu'affiche ce programme ?
`python
L = [4, 9, 2, 9]
imax = 0
for i in range(len(L)):
if L[i] >= L[imax]:
imax = i
print(imax)
`

]]> Le choix entre > et >= décide quelle occurrence du maximum
est retenue : la première ou la dernière.

]]> 1.0 0.0 0 true true abc 1, la première occurrence de 9

]]> Erreur : ce serait le résultat avec > strict ; >= continue
de mettre imax à jour en cas d'égalité.

]]> 9, la valeur du maximum

]]> Erreur : le programme affiche un indice, pas une valeur.

]]> 3, la dernière occurrence de 9

]]> Bonne réponse : avec >=, une égalité remplace imax ; le
programme retient la dernière position du maximum.

]]> 0, imax ne changeant jamais

]]> Erreur : dès qu'un élément dépasse ou égale L[0], imax
change.

]]> Algorithmique et listes — Q35 : Un terme d'une suite récurrente par une boucle La suite (uₙ) est définie par u₀ = 1 et
uₙ₊₁ = 2uₙ + 1. Qu'affiche ce programme ?
`python
u = 1
for k in range(3):
u = 2 * u + 1
print(u)
`

]]> Pour calculer uₙ, on part de u₀ et on applique n fois la
relation de récurrence : range(n) fait exactement n tours.

]]> 1.0 0.0 0 true true abc 31, la valeur de u₄

]]> Erreur : range(3) fait trois tours, pas quatre.

]]> 7, la valeur de u₂

]]> Erreur : range(3) fait trois tours, pas deux.

]]> 1, la valeur de u₀

]]> Erreur : u est modifié à chaque tour.

]]> 15, la valeur de u₃

]]> Bonne réponse : trois tours de boucle calculent u₁, u₂
puis u₃ = 15.

]]> Algorithmique et listes — Q36 : Liste des premiers termes d'une suite arithmétique Qu'affiche print([3 + 2 * k for k in range(5)]) ?

]]> Une liste en compréhension génère les termes uₖ = 3 + 2k :
une suite arithmétique sous forme explicite.

]]> 1.0 0.0 0 true true abc [5, 7, 9, 11, 13]

]]> Erreur : range(5) commence à 0, le premier terme est donc
3.

]]> [3, 6, 12, 24, 48]

]]> Erreur : 3 + 2 * k est une expression affine, pas une
puissance ; la suite est arithmétique.

]]> [3, 5, 7, 9, 11]

]]> Bonne réponse : pour k de 0 à 4, on obtient les cinq
premiers termes de la suite arithmétique de premier terme 3
et de raison 2.

]]> [3, 5, 7, 9]

]]> Erreur : range(5) produit cinq valeurs, de 0 à 4.

]]> Algorithmique et listes — Q37 : Un algorithme de seuil pour une suite croissante Qu'affiche ce programme ?
`python
u = 10
n = 0
while u < 100:
u = 1.5 * u
n = n + 1
print(n)
`

]]> Un algorithme de seuil répète la relation de récurrence jusqu'à
dépasser la valeur visée et compte les étapes.

]]> 1.0 0.0 0 true true abc 113{,}9, la valeur finale de u

]]> Erreur : le programme affiche n, pas u.

]]> 6, premier rang où uₙ ≥ 100

]]> Bonne réponse : chaque tour multiplie u par 1{,}5 et
incrémente n ; la boucle s'arrête quand u atteint ou
dépasse 100, soit u_{6} \approx 113{,}9, après 6
tours.

]]> 5, dernier rang où uₙ < 100

]]> Erreur : au rang 5, u est encore sous le seuil ; la
boucle fait un tour de plus.

]]> 100, le seuil de la boucle

]]> Erreur : 100 est le seuil, pas le nombre de tours.

]]> Algorithmique et listes — Q38 : Moyenne avec sum et len Avec L = [4, 7, 1], que vaut sum(L) / len(L) ?

]]> sum et len suffisent pour calculer une moyenne sans boucle.

]]> 1.0 0.0 0 true true abc 3, le nombre d'éléments seul

]]> Erreur : len(L) est le diviseur, pas le résultat.

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

]]> Erreur : la somme est ensuite divisée par len(L).

]]> 4, un quotient entier de 12 par 3

]]> Erreur : / renvoie toujours un flottant, ici 4.0.

]]> 4.0, le quotient de 12 par 3

]]> Bonne réponse : sum(L) vaut 12, len(L) vaut 3, et la
division / donne un flottant.

]]> Algorithmique et listes — Q39 : Additionner deux listes Que vaut [1, 2] + [3] ?

]]> Comme pour les chaînes, + juxtapose deux listes.

]]> 1.0 0.0 0 true true abc [1, 2, 3], les deux listes mises bout à bout

]]> Bonne réponse : entre deux listes, + concatène.

]]> Une erreur, les listes n'ayant pas la même longueur

]]> Erreur : la concaténation n'impose aucune longueur.

]]> [[1, 2], 3], la seconde liste ajoutée comme élément

]]> Erreur : ce serait le résultat de [[1, 2]] + [3] ou
d'un append.

]]> [4, 5], chaque élément augmenté de 3

]]> Erreur : + ne fait pas de calcul terme à terme sur les
listes.

]]> Algorithmique et listes — Q40 : Transformer et filtrer une liste Avec L = [2, 5, 3], que vaut [x * 2 for x in L if x > 2] ?

]]> Dans une compréhension, le filtre if sélectionne les éléments et
l'expression de tête les transforme.

]]> 1.0 0.0 0 true true abc [4, 10, 6], tous les éléments doublés

]]> Erreur : la condition if x > 2 écarte 2.

]]> [5, 3], les éléments retenus sans transformation

]]> Erreur : l'expression x * 2 s'applique à chaque élément
retenu.

]]> [10, 6, 4], les éléments doublés puis rangés

]]> Erreur : une compréhension ne trie pas et exclut 2.

]]> [10, 6], les éléments supérieurs à 2 doublés

]]> Bonne réponse : seuls 5 et 3 passent le filtre, puis
chacun est doublé.

]]> Algorithmique et listes — Q41 : Chercher une valeur avec une boucle tant que Qu'affiche ce programme ?
`python
L = [6, 2, 8, 2, 5]
i = 0
while L[i] != 2:
i = i + 1
print(i)
`

]]> Une boucle while permet d'arrêter un parcours dès que la valeur
cherchée est trouvée.

]]> 1.0 0.0 0 true true abc 2, la valeur cherchée

]]> Erreur : le programme affiche l'indice i, pas la valeur.

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

]]> Bonne réponse : la boucle avance tant que L[i] diffère de
2 et s'arrête sur la première case qui le contient.

]]> 5, la longueur de la liste

]]> Erreur : la boucle s'arrête avant d'avoir parcouru toute la
liste.

]]> 3, l'indice de la dernière occurrence de 2

]]> Erreur : la boucle s'arrête dès la première occurrence.

]]> Algorithmique et listes — Q42 : Une récurrence qui dépend du rang Qu'affiche ce programme ?
`python
u = 1
for n in range(4):
u = u + 2 * n + 1
print(u)
`

]]> Quand la relation de récurrence fait intervenir n, la variable de
boucle fournit ce rang à chaque tour.

]]> 1.0 0.0 0 true true abc 17, soit 1 + 4²

]]> Bonne réponse : les ajouts valent 1, 3, 5, … pour
n = 0, 1, 2, … ; leur somme sur 4 tours vaut 4².

]]> 16, sans le terme initial

]]> Erreur : u part de 1, pas de 0.

]]> 8, le dernier ajout seul

]]> Erreur : u accumule tous les ajouts depuis 1.

]]> 26, un tour de plus

]]> Erreur : range(4) fait exactement 4 tours, de n = 0
à n = 3.

]]> Algorithmique et listes — Q43 : Somme harmonique dépassant un seuil Qu'affiche ce programme ?
`python
s = 0
n = 0
while s < 2:
n = n + 1
s = s + 1 / n
print(n)
`

]]> Un algorithme de seuil sur une somme ajoute les termes un à un et
compte le rang atteint.

]]> 1.0 0.0 0 true true abc 3, dernier rang où la somme reste sous 2

]]> Erreur : pour n = 3, s vaut environ 1{,}83 < 2 et la
boucle continue.

]]> 4, premier rang où la somme atteint 2

]]> Bonne réponse : les sommes successives valent 1 ; 1{,}5 ;
environ 1{,}83 ; environ 2{,}08 : la boucle s'arrête au
quatrième terme.

]]> 2, le seuil comparé à la somme

]]> Erreur : 2 est la valeur comparée, pas le nombre de termes.

]]> 2.083…, la valeur finale de la somme s

]]> Erreur : le programme affiche n, pas s.

]]> Algorithmique et listes — Q44 : Simuler un succès de probabilité 0,3 Qu'affiche ce programme ?
`python
from random import random
c = 0
for i in range(1000):
if random() < 0.3:
c = c + 1
print(c / 1000)
`

]]> Comparer random() à p simule une épreuve de succès de
probabilité p.

]]> 1.0 0.0 0 true true abc Exactement 0.3, la probabilité programmée

]]> Erreur : une fréquence simulée fluctue autour de la
probabilité.

]]> Un nombre proche de 0.5, random étant uniforme

]]> Erreur : random() est uniforme sur [0 ; 1[, donc inférieur
à 0{,}3 trois fois sur dix en moyenne.

]]> Un nombre proche de 0.3, variable d'une exécution à l'autre

]]> Bonne réponse : random() < 0.3 est vrai avec une probabilité
0{,}3 ; la fréquence observée sur 1000 essais s'en
approche sans être exacte.

]]> 300, le nombre de succès

]]> Erreur : le programme divise c par 1000 et c n'est pas
exactement 300.

]]> Algorithmique et listes — Q45 : Balayage au pas de un dixième Qu'affiche ce programme ?
``python
def f(x):
return x ** 2 - 2

k = 0
while f(1 + k / 10) < 0:
k = k + 1
print(1 + k / 10)
``

]]> Le balayage à pas fixe encadre la solution de f(x) = 0 entre deux
valeurs consécutives de signes contraires.

]]> 1.0 0.0 0 true true abc 1.4, dernière valeur où f(x) < 0

]]> Erreur : en 1{,}4 la condition est encore vraie, la boucle
continue.

]]> 1.5, première valeur où f(x) ≥ 0

]]> Bonne réponse : f(1{,}4) = -0{,}04 < 0 et f(1{,}5) = 0{,}25 ;
la boucle s'arrête pour k = 5.

]]> 5, le nombre de tours de la boucle

]]> Erreur : le programme affiche 1 + k / 10, pas k.

]]> 1.4142…, la racine carrée de 2

]]> Erreur : le balayage ne s'arrête que sur les valeurs
1 + k/10.

]]>