Algorithmique et programmation | Terminale technologique (enseignement commun) | Mathématiques
Dernière mise à jour : 21 octobre 2026
S = 0 somme, P = 1 produit), boucler, accumuler, renvoyer.c = c + 1 à chaque évènement compté.append, compréhension ; indices de \(0\) à len(liste) - 1.random() \(\in [0,1[\) ; succès si random() < p.Écrire une fonction somme_inverses(n) renvoyant \(1 + \dfrac{1}{2} + \dots + \dfrac{1}{n}\). Que renvoie somme_inverses(4) ?
def somme_inverses(n):
S = 0
for k in range(1, n + 1):
S = S + 1/k
return Ssomme_inverses(4) \(= 1 + \dfrac{1}{2} + \dfrac{1}{3} + \dfrac{1}{4} = \dfrac{25}{12} \approx 2{,}083\).
Que renvoie l'appel mystere([3, 4, 7, 8, 10]) ?
def mystere(liste):
c = 0
for x in liste:
if x % 2 == 0:
c = c + 1
return cLa fonction compte les nombres pairs de la liste : \(4\), \(8\), \(10\). Elle renvoie 3.
1. Générer, en compréhension, la liste des multiples de \(5\) strictement inférieurs à \(50\).
2. Générer la liste des carrés \([0, 1, 4, 9, 16]\) de deux façons : par ajouts successifs (append) puis en compréhension.
1. [k for k in range(50) if k % 5 == 0] → [0, 5, 10, 15, 20, 25, 30, 35, 40, 45].
b = []
for k in range(5):
b.append(k**2) # b = [0, 1, 4, 9, 16]
c = [k**2 for k in range(5)] # même résultatOn veut l'amplitude (max − min) d'une liste. Écrire maximum(liste) et minimum(liste), puis amplitude(liste) qui les réutilise.
def maximum(liste):
m = liste[0]
for x in liste:
if x > m:
m = x
return m
def minimum(liste):
m = liste[0]
for x in liste:
if x < m:
m = x
return m
def amplitude(liste):
return maximum(liste) - minimum(liste)Écrire une fonction simule_dizaine(p) qui simule \(10\) épreuves de Bernoulli de paramètre p et renvoie le nombre de succès.
from random import random
def simule_dizaine(p):
succes = 0
for _ in range(10):
if random() < p:
succes += 1
return succesChaque tour est un succès si random() (entre \(0\) et \(1\)) est inférieur à p.
Une population de \(2000\) habitants augmente de \(4\,\%\) par an. Écrire une fonction annees_pour_doubler() qui renvoie le plus petit nombre d'années au bout duquel la population a doublé.
def annees_pour_doubler():
n = 0
valeur = 2000
while valeur < 4000:
valeur = valeur * 1.04
n = n + 1
return nOn répète tant que la valeur n'a pas atteint \(4000\). La fonction renvoie 18 (car \(1{,}04^{18} \approx 2{,}03\)).
Cette fonction est censée calculer la moyenne d'une liste, mais elle est fausse. Trouver et corriger l'erreur.
def moyenne(liste):
total = 0
for x in liste:
total = total + x
return total / len(liste) - 1La priorité des opérations calcule (total / len(liste)) - 1 : on retranche \(1\) à tort. Il faut supprimer le - 1 :
return total / len(liste)On veut estimer, par simulation, la probabilité d'obtenir au moins 3 succès lorsqu'on répète \(10\) fois une épreuve de Bernoulli de paramètre \(p = 0{,}3\).
1. Écrire une fonction bernoulli(p) renvoyant \(1\) (succès) avec probabilité \(p\), sinon \(0\).
2. Écrire compte_succes(n, p) qui renvoie le nombre de succès sur \(n\) répétitions.
3. Écrire frequence_au_moins_3(N) qui, sur \(N\) simulations de \(10\) épreuves, renvoie la fréquence des cas où le nombre de succès est \(\ge 3\).
from random import random
def bernoulli(p):
if random() < p:
return 1
else:
return 0
def compte_succes(n, p):
total = 0
for _ in range(n):
total = total + bernoulli(p) # accumulateur de succès
return total
def frequence_au_moins_3(N):
compteur = 0
for _ in range(N):
if compte_succes(10, 0.3) >= 3:
compteur = compteur + 1 # compteur d'évènements favorables
return compteur / NOn combine ici les deux motifs : accumulateur de succès dans compte_succes et compteur d'évènements favorables dans frequence_au_moins_3. La fréquence obtenue est proche de \(0{,}62\) (probabilité théorique avec \(B(10 ; 0{,}3)\)).