Aller au contenu
OptiTAB

Maths Terminale · Chapitre 4 · Algorithmique et programmation

Algorithmes du programme de Terminale

  • 8 parties
  • 6 schémas
  • Lecture ≈ 18 min
  • Conforme au programme
Objectifs

Écrire, lire et utiliser en Python les algorithmes cités par le programme de Terminale : terme, somme et seuil d'une suite ; méthode de dichotomie et méthode de Newton ; méthode des rectangles ; seuils avec l'exponentielle et le logarithme ; simulation d'un schéma de Bernoulli, d'une loi binomiale et d'échantillons ; génération de listes en dénombrement.

Prérequis

Programmes de Seconde et de Première : variables, fonctions def, instructions if, boucles for et while, listes (voir la notion « Notion de liste »). Terminale : suites et limites, continuité, logarithme, calcul intégral, loi binomiale, loi des grands nombres, dénombrement.

ILes outils

Le programme de Terminale n'introduit aucune instruction nouvelle : il applique les outils de Seconde et de Première à chaque partie du cours.

RappelRappel de Seconde et de Première
  • def f(x): puis return … définit une fonction qui renvoie un résultat.
  • if condition: … else: … exécute un bloc ou l'autre.
  • for k in range(n): répète un bloc n fois ; k prend les valeurs 0, 1, …, n−1.
  • while condition: répète un bloc tant que la condition est vraie.
  • Un accumulateur s'initialise avant la boucle : 0 pour une somme ou un compteur, 1 pour un produit.
  • L.append(x) ajoute x à la fin de la liste L.
AlgorithmeBoucle utilisée
terme un, somme, rectanglesfor : nombre de tours connu
seuil, dichotomiewhile : tant que le but n'est pas atteint
simulation de N expériencesfor et un compteur
RemarqueSimulations : la graine

Le module random produit des nombres pseudo-aléatoires : ils sont calculés à partir d'un point de départ, la graine. L'instruction seed(2026) fixe cette graine : le programme donne alors toujours le même affichage, et c'est celui que l'on imprime ici. Sans seed, ou avec une autre graine, on obtient d'autres résultats, de même allure.

IISuites numériques

1. Terme de rang n et somme de termes

La suite (un) est définie par u0=1 et, pour tout entier naturel n, un+1=0,8un+2.

MéthodeTerme et somme
  • Terme un : on part de u0 et on applique n fois la relation de récurrence (boucle for de n tours).
  • Somme u0+⋯+un : un accumulateur s et le terme u avancent ensemble ; il y a n+1 termes, donc n+1 tours.
Python
def terme(n):
    u = 1
    for k in range(n):
        u = 0.8 * u + 2
    return u

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

print(round(terme(3), 4))
print(round(somme(3), 4))
Affichage
5.392
13.432

On vérifie : u1=2,8, u2=4,24, u3=5,392 et

u0+u1+u2+u3=1+2,8+4,24+5,392=13,432
RemarqueLa forme explicite

La suite définie par vn=un−10 vérifie

vn+1=0,8un+2−10=0,8(un−10)=0,8vn

Elle est géométrique de raison 0,8 et v0=−9. Donc un=10−9×0,8n, et (un) converge vers 10 car −1<0,8<1.

2. Algorithme de seuil

MéthodePlus petit rang n tel que un>A

On calcule les termes un par un tant que le seuil n'est pas dépassé, en comptant les tours. La condition du while est le contraire de la condition cherchée : on veut un>A, on répète donc tant que u≤A. À la sortie, n est le rang cherché.

Python
def seuil(A):
    n = 0
    u = 1
    while u <= A:
        u = 0.8 * u + 2
        n = n + 1
    return n

print(seuil(9))
Affichage
10
Termes de la suite u(n+1) = 0,8 u(n) + 2 avec u0 = 1 : ils dépassent le seuil 9 à partir de u10 ≈ 9,03 et restent sous la droite y = 10, jamais atteinte
Vérification par le logarithme
un>9⟺10−9×0,8n>9⟺0,8n<19⟺nln⁡(0,8)<−ln⁡(9)⟺n>ln⁡(9)−ln⁡(0,8)

On a divisé par ln⁡(0,8)<0, ce qui change le sens de l'inégalité. Comme ln⁡(9)−ln⁡(0,8)≈9,85, le plus petit entier est bien n=10.

3. Une suite majorée qui ne dépasse jamais le seuil

Un algorithme de seuil ne s'arrête que si le seuil est réellement dépassé à partir d'un certain rang. Ici, l'appel seuil(10) ne se termine jamais.

DémonstrationPour tout n, un<10

Par récurrence. Initialisation : u0=1<10. Hérédité : si un<10, alors 0,8un<8, donc un+1=0,8un+2<10. La propriété est vraie pour tout entier naturel n.

La condition u <= 10 reste donc toujours vraie : la boucle est infinie. La suite converge vers 10 sans jamais l'atteindre.

ConseilUn garde-fou

On limite le nombre de tours avec un second paramètre nmax, puis on teste si le seuil a bien été dépassé. La fonction renvoie None (« rien ») sinon.

Python
def seuil2(A, nmax):
    n = 0
    u = 1
    while u <= A and n < nmax:
        u = 0.8 * u + 2
        n = n + 1
    if u > A:
        return n
    return None

print(seuil2(9, 1000))
print(seuil2(10, 1000))
Affichage
10
None

IIIContinuité : résoudre f(x)=0

La fonction f:x↦x3+x−1 est continue et strictement croissante sur [0;1] (car f′(x)=3x2+1>0), avec f(0)=−1<0 et f(1)=1>0. D'après le corollaire du théorème des valeurs intermédiaires, l'équation f(x)=0 admet une unique solution α dans [0;1].

1. La méthode de dichotomie

MéthodeDichotomie

On part d'un intervalle [a;b] qui contient α. À chaque tour, on calcule le milieu m=a+b2 :

  • si f(a) et f(m) sont de signes contraires, c'est-à-dire f(a)×f(m)≤0, la solution est dans [a;m] : on remplace b par m ;
  • sinon, elle est dans [m;b] : on remplace a par m.

On s'arrête quand l'amplitude b−a est inférieure ou égale à la précision e.

Python
def f(x):
    return x**3 + x - 1

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

print(dichotomie(0, 1, 0.01))
Affichage
(0.6796875, 0.6875)
Tourmsigne de f(m)nouvel intervalle
10,5−[0,5;1]
20,75+[0,5;0,75]
30,625−[0,625;0,75]
40,6875+[0,625;0,6875]
Courbe de y = x³ + x − 1 sur [0 ; 1] coupant l'axe des abscisses en alpha, et intervalles successifs de la dichotomie aux tours 0 à 4 : [0 ; 1], [0,5 ; 1], [0,5 ; 0,75], [0,625 ; 0,75] et [0,625 ; 0,6875]

L'amplitude est divisée par 2 à chaque tour : après n tours, elle vaut 12n. Comme 126>0,01 et 127=1128≤0,01, la boucle fait 7 tours : 0,6796<α<0,6875.

2. La méthode de Newton

MéthodeMéthode de Newton

On part d'une valeur x0 proche de α. La tangente à la courbe au point d'abscisse xn coupe l'axe des abscisses en xn+1 :

xn+1=xn−f(xn)f′(xn)

Dans les cas favorables (comme ici), la suite (xn) converge très vite vers α.

DémonstrationD'où vient la formule

La tangente au point d'abscisse xn a pour équation y=f′(xn)(x−xn)+f(xn). Elle coupe l'axe des abscisses quand y=0, c'est-à-dire, si f′(xn)≠0, pour x=xn−f(xn)f′(xn).

Méthode de Newton pour y = x³ + x − 1 : la tangente au point d'abscisse x0 = 1 coupe l'axe en x1 = 0,75, la tangente au point d'abscisse x1 le coupe en x2, très proche de la solution
Python
def fp(x):
    return 3 * x**2 + 1

x = 1
for k in range(4):
    x = x - f(x) / fp(x)
    print(k + 1, x)
Affichage
1 0.75
2 0.686046511627907
3 0.6823395825973142
4 0.6823278039465127

Après 4 tours, x4≈0,682327804 : ses neuf premières décimales sont celles de α (au tour suivant, Python affiche 0.6823278038280194). La dichotomie, elle, gagne environ une décimale tous les 3 ou 4 tours.

AttentionLes limites de la méthode de Newton

Il faut connaître la dérivée f′, et la méthode échoue si f′(xn)=0 ; si l'on part d'une valeur trop éloignée de α, la suite peut même s'en écarter. La dichotomie est lente mais toujours sûre ; la méthode de Newton est rapide quand on part près de la solution.

IVCalcul intégral : la méthode des rectangles

Soit f continue et positive sur [a;b]. On partage [a;b] en n intervalles de même largeur h=b−an, d'extrémités xk=a+kh. Sur chaque petit intervalle, on remplace l'aire sous la courbe par l'aire d'un rectangle de largeur h.

MéthodeRectangles à gauche, rectangles à droite
  • À gauche, les hauteurs sont f(x0), …, f(xn−1) ;
  • à droite, les hauteurs sont f(x1), …, f(xn).
S=h∑k=0n−1f(xk)(a` gauche)s=h∑k=1nf(xk)(a` droite)

Si f est décroissante, s≤∫abf(x)dx≤S (inégalités inversées si f est croissante).

ExempleEncadrer ln⁡(2)=∫121xdx

La fonction inverse est décroissante sur [1;2] : les rectangles à droite donnent une valeur approchée par défaut s, les rectangles à gauche une valeur approchée par excès S.

Python
def f(x):
    return 1 / x

def gauche(a, b, n):
    h = (b - a) / n
    S = 0
    for k in range(n):
        S = S + h * f(a + k*h)
    return S

def droite(a, b, n):
    h = (b - a) / n
    s = 0
    for k in range(1, n + 1):
        s = s + h * f(a + k*h)
    return s

for n in [4, 10, 100]:
    s = round(droite(1, 2, n), 4)
    S = round(gauche(1, 2, n), 4)
    print(n, s, S)
Affichage
4 0.6345 0.7595
10 0.6688 0.7188
100 0.6907 0.6957
Courbe de y = 1/x sur [1 ; 2] avec 4 rectangles à gauche, au-dessus de la courbe (somme S), et 4 rectangles à droite, sous la courbe (somme s)

Avec n=100 : 0,6907≤ln⁡(2)≤0,6957, et en effet ln⁡(2)≈0,6931. Les termes communs se simplifient : S−s=h(f(1)−f(2))=12n, qui tend vers 0 quand n augmente.

VExponentielle et logarithme : seuils

MéthodeDeux façons de trouver un seuil
  • Par un algorithme : on teste n=0, 1, 2, … avec une boucle while ; on obtient le plus petit entier qui convient.
  • Par le calcul : on résout l'inéquation avec la fonction ln (croissante) ou la fonction exp. C'est le calcul qui démontre le résultat.
ExempleUn capital placé à 3% par an

Un capital de 1000 € augmente de 3% par an : au bout de n années, il vaut 1000×1,03n. Au bout de combien d'années aura-t-il doublé ?

Python
n = 0
c = 1000
while c <= 2000:
    c = c * 1.03
    n = n + 1
print(n, round(c, 2))
Affichage
24 2032.79

Par le calcul, comme ln⁡(1,03)>0 :

1,03n>2⟺nln⁡(1,03)>ln⁡(2)⟺n>ln⁡(2)ln⁡(1,03)≈23,45

Le capital a doublé au bout de 24 ans.

ExempleUne décroissance exponentielle

La masse d'un produit radioactif vaut m(t)=100e−0,3t grammes au bout de t jours. On cherche à partir de quand elle est inférieure à 1 gramme.

Python
from math import exp

t = 0
while 100 * exp(-0.3*t) >= 1:
    t = t + 1
print(t)
Affichage
16

Par le calcul :

100e−0,3t<1⟺e−0,3t<0,01⟺−0,3t<ln⁡(0,01)⟺t>ln⁡(100)0,3≈15,35

On a divisé par −0,3<0 et utilisé −ln⁡(0,01)=ln⁡(100). Le premier nombre entier de jours est bien 16.

RemarqueUn pas plus fin

En remplaçant t = t + 1 par t = round(t + 0.01, 2), la même boucle avance de 0,01 en 0,01 et affiche 15.36 : c'est une valeur approchée par excès, au centième, de ln⁡(100)0,3. La fonction round efface les erreurs d'arrondi des décimaux en machine.

VIProbabilités : simuler

1. Schéma de Bernoulli et loi binomiale

random() renvoie un nombre au hasard dans [0;1[ : le test random() < p est vrai avec la probabilité p. La fonction bernoulli(p) simule donc une épreuve de Bernoulli de paramètre p (elle renvoie 1 pour un succès, 0 pour un échec). La somme de n épreuves indépendantes suit la loi binomiale B(n;p).

Python
from random import random, seed

def bernoulli(p):
    if random() < p:
        return 1
    return 0

def binomiale(n, p):
    x = 0
    for k in range(n):
        x = x + bernoulli(p)
    return x

seed(2026)
R = []
for k in range(10):
    R.append(bernoulli(0.3))
print(R)
print(binomiale(10, 0.3))
Affichage
[1, 0, 0, 0, 1, 1, 0, 0, 0, 0]
2

La liste R contient les résultats de 10 épreuves : 3 succès ici. Le dernier appel simule une valeur de X∼B(10;0,3) : on a obtenu 2 succès sur 10.

2. Fréquences observées et probabilités

On simule N=1000 valeurs de X, qui suit B(10;0,3). La liste E compte combien de fois chaque valeur k est obtenue : E[k] est l'effectif de k.

Python
seed(2026)
N = 1000
E = [0] * 11
for i in range(N):
    x = binomiale(10, 0.3)
    E[x] = E[x] + 1
for k in range(11):
    print(k, E[k])
Affichage
0 32
1 123
2 219
3 265
4 198
5 110
6 40
7 10
8 2
9 1
10 0

On compare les fréquences E[k]N aux probabilités P(X=k)=(10k)0,3k0,710−k, calculées avec la fonction comb du module math.

Python
from math import comb

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

for k in range(6):
    pk = p_binom(10, 0.3, k)
    f = E[k] / N
    print(k, f, round(pk, 3))
Affichage
0 0.032 0.028
1 0.123 0.121
2 0.219 0.233
3 0.265 0.267
4 0.198 0.2
5 0.11 0.103
Diagramme en barres des fréquences observées sur 1000 simulations de la loi binomiale B(10 ; 0,3), comparées aux probabilités P(X = k)

3. Calculer un seuil pour une loi binomiale

MéthodePlus petit k tel que P(X≤k)≥a

On ajoute les probabilités P(X=0), P(X=1), … tant que leur somme est inférieure à a. On utilise la fonction p_binom ci-dessus.

Python
def seuil_binom(n, p, a):
    k = 0
    s = p_binom(n, p, 0)
    while s < a:
        k = k + 1
        s = s + p_binom(n, p, k)
    return k, round(s, 4)

print(seuil_binom(10, 0.3, 0.95))
Affichage
(5, 0.9527)

Pour X∼B(10;0,3) : P(X≤4)≈0,8497<0,95 et P(X≤5)≈0,9527≥0,95, donc k=5. Ce type de calcul sert aussi à résoudre un problème de surréservation.

4. Échantillons et loi des grands nombres

La fréquence des succès dans un échantillon de taille n est la moyenne de n variables de Bernoulli indépendantes. D'après la loi des grands nombres, elle se rapproche de p quand n devient grand.

Python
seed(2026)
for n in [10, 100, 1000, 10000]:
    s = 0
    for i in range(n):
        s = s + bernoulli(0.3)
    print(n, s / n)
Affichage
10 0.3
100 0.21
1000 0.285
10000 0.308

Les fréquences fluctuent beaucoup pour de petits échantillons, puis se stabilisent autour de p=0,3.

VIIDénombrement : générer des listes

1. Le triangle de Pascal

MéthodeRelation de Pascal

Pour 1≤k≤n : (n+1k)=(nk−1)+(nk). Chaque ligne du triangle se déduit de la précédente : elle commence et finit par 1, et chaque autre nombre est la somme des deux nombres voisins de la ligne du dessus.

Triangle de Pascal des lignes 0 à 5 : les nombres 4 et 6 de la ligne 4 s'additionnent pour donner 10 sur la ligne 5
Python
def suivante(L):
    M = [1]
    for k in range(len(L) - 1):
        M.append(L[k] + L[k + 1])
    M.append(1)
    return M

L = [1]
for n in range(6):
    print(L)
    L = suivante(L)
Affichage
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]

La ligne n contient les coefficients (n0), (n1), …, (nn) : par exemple (52)=10.

2. Les parties à 2 éléments d'un ensemble

ExempleParties à 2 éléments de {a,b,c,d}

Deux boucles imbriquées : pour chaque indice i, l'indice j parcourt les indices suivants ; chaque partie est ainsi obtenue une seule fois.

Python
E = ["a", "b", "c", "d"]
P = []
for i in range(len(E)):
    for j in range(i + 1, len(E)):
        P.append([E[i], E[j]])
for c in P:
    print(c)
print(len(P))
Affichage
['a', 'b']
['a', 'c']
['a', 'd']
['b', 'c']
['b', 'd']
['c', 'd']
6

On retrouve (42)=4×32=6. La même liste s'écrit aussi en compréhension : voir la notion « Notion de liste ».

VIIIBilan

Partie du programmeAlgorithmes
Suitesterme un, somme (for) ; seuil, suite majorée (while)
Continuitédichotomie (while, if) ; méthode de Newton
Calcul intégralrectangles (for, accumulateur)
Exp et lnseuils (while, puis ln)
ProbabilitésBernoulli, binomiale, échantillons (random, compteur)
Dénombrementtriangle de Pascal, parties (listes)
RemarqueAutres exemples cités par le programme

Méthode de la sécante, algorithme de Briggs (logarithme), méthode d'Euler pour y′=ay+b, méthodes des milieux et des trapèzes, méthode de Monte-Carlo, planche de Galton, marche aléatoire : ils utilisent les mêmes outils.

AttentionPièges fréquents
  • Dans un algorithme de seuil, la condition du while est le contraire de la condition cherchée.
  • Avant de chercher un seuil, on vérifie qu'il sera dépassé (suite majorée : boucle infinie).
  • Diviser une inégalité par ln⁡(q)<0 (quand 0<q<1) change son sens.
  • Dichotomie : on garde la moitié où f change de signe, et on s'arrête sur l'amplitude b−a, pas sur f(m).
  • Rectangles : range(n) pour les rectangles à gauche (x0 à xn−1), range(1, n + 1) à droite.
  • Une simulation sans seed donne un résultat différent à chaque exécution.
À retenir
  • Seuil : while u <= A: et un compteur, puis vérification par le logarithme.
  • Dichotomie : l'amplitude est divisée par 2 à chaque tour.
  • Newton : xn+1=xn−f(xn)f′(xn).
  • Rectangles : h× (somme des hauteurs), avec h=b−an.
  • Bernoulli : random() < p ; binomiale : somme de n Bernoulli ; la fréquence tend vers p.
  • Pascal : chaque coefficient est la somme des deux nombres voisins de la ligne du dessus.

Fiche de synthèse dans l'onglet Fiches !

Cours lu ? Continue avec :

Plateforme OptiTAB

S’entraîner jusqu’à maîtriser le programme de Terminale

Les 12 exercices corrigés de ce chapitre, le suivi de tes progrès et des révisions guidées.

Découvrir l’abonnement

Cours particuliers

Un prof de maths en Terminale, en ligne

Des séances individuelles avec un professeur, à distance, pour comprendre, combler ses lacunes et préparer les contrôles et le bac.

Réserver un cours particulier