I. Les outils du langage
Le programme de Terminale n'introduit aucune notion nouvelle par rapport à la Première. Les algorithmes attendus combinent des briques déjà connues : boucles, conditions, listes et fonctions.
| structure | usage typique |
|---|---|
boucle bornée for | nombre de répétitions connu |
boucle non bornée while | recherche de seuil |
| liste en compréhension | termes d'une suite, échantillon |
fonction avec return | brique réutilisable |
Le programme insiste sur ce point : chaque fonction doit faire une seule chose, et les fonctions se réutilisent entre elles.
Un exercice demande souvent d'écrire une fonction courte qui en appelle une autre, déjà donnée dans l'énoncé. Lire attentivement ce qui est fourni évite de tout réécrire.
II. Algorithmes sur les suites
Pour la suite définie par et , cherchons le premier rang où la suite dépasse une valeur donnée.
def seuil(limite):
u = 1
n = 0
while u <= limite:
u = 1.05 * u + 2
n = n + 1
return n
La boucle non bornée s'impose ici : le nombre d'étapes n'est pas connu à l'avance.
def termes(n):
L = [1]
for i in range(n):
L.append(1.05 * L[-1] + 2)
return L
Une boucle non bornée dont la condition ne peut jamais devenir fausse tourne indéfiniment. Avant de lancer le programme, il faut s'assurer que la suite étudiée dépasse effectivement le seuil visé.
III. Algorithmes d'analyse
Cet algorithme encadre la solution d'une équation lorsque le théorème des valeurs intermédiaires en garantit l'existence et l'unicité.
def dichotomie(f, a, b, precision):
while b - a > precision:
m = (a + b) / 2
if f(a) * f(m) <= 0:
b = m
else:
a = m
return a, b
Elle construit une approximation de la solution d'une équation différentielle en suivant la tangente sur chaque petit intervalle.
def euler(a, b, y0, pas, n):
y = y0
valeurs = [y0]
for i in range(n):
y = y + pas * (a * y + b)
valeurs.append(y)
return valeurs
def rectangles(f, a, b, n):
pas = (b - a) / n
somme = 0
for i in range(n):
somme = somme + f(a + i * pas) * pas
return somme
Le résultat s'approche de l'intégrale lorsque le nombre de découpages augmente.
IV. Algorithmes de probabilités
from math import comb
def p_egal(n, p, k):
return comb(n, k) * p ** k * (1 - p) ** (n - k)
def p_inf(n, p, k):
cumul = 0
for i in range(k + 1):
cumul = cumul + p_egal(n, p, i)
return cumul
La seconde fonction réutilise la première, ce qui évite de dupliquer la formule.
from random import random
def echantillon(n, p):
# 1 pour un succes, 0 sinon
return [1 if random() < p else 0 for i in range(n)]
def frequence(n, p):
L = echantillon(n, p)
return sum(L) / n
En répétant l'appel à frequence pour différentes valeurs de , on observe directement la concentration décrite par la loi des grands nombres.
from random import randint
def marche(n):
position = 0
trajet = [0]
for i in range(n):
if randint(0, 1) == 1:
position = position + 1
else:
position = position - 1
trajet.append(position)
return trajet
Passer à la pratique
9 exercices corrigés sur ce chapitre.