Mathématiques (spécialité) · TerminaleBac

Suites et algorithmes : cours de Terminale spécialité maths

Publié le 6 novembre 2026 · Mis à jour le 6 novembre 2026 · Signaler une erreur

L'essentiel

Un algorithme est une succession finie d'instructions précises ; pour une suite, il calcule des termes avec une boucle for quand le nombre de répétitions est connu.
Un algorithme de seuil utilise une boucle while : on avance de terme en terme tant que la condition d'arrêt n'est pas atteinte, puis on renvoie le rang $n$ .
Il ne termine que si la suite finit réellement par franchir le seuil : une suite croissante qui tend vers $+\infty$ le franchit toujours, une suite croissante convergente jamais si le seuil est au moins égal à sa limite.
Un algorithme permet de conjecturer ; seule une démonstration (récurrence, limite, théorèmes de comparaison ou de convergence monotone) prouve.
Pièges classiques : mauvais sens de l'inégalité, oubli de $n = n + 1$ , renvoi de $u$ au lieu de $n$ , seuil inatteignable.

Pourquoi associer suites et algorithmes

En Terminale, tu manipules des suites dont tu étudies le sens de variation, la convergence et la limite. Pourtant, une question très concrète revient dans les sujets : à partir de quel rang une suite dépasse-t-elle 1000 ? À partir de quel rang reste-t-elle à moins d'un centième de sa limite ? Calculer à la main les termes un par un serait interminable. C'est là qu'intervient l'algorithme : tu demandes à une machine de répéter le calcul à ta place.

Le programme de Terminale s'organise autour des notions de suite et de fonction, et les ressources d'accompagnement rappellent que les capacités attendues comprennent le fait de calculer, d'appliquer des techniques et de mettre en œuvre des algorithmes ¹. Les documents de cycle terminal précisent aussi que l'on entraîne les élèves à décrire des algorithmes en langage naturel ou dans un langage de programmation, et à en réaliser quelques-uns avec un tableur ou un programme ².

Ce cours suit un fil simple :

comprendre ce qu'est un algorithme et d'où vient le mot ;
programmer le calcul des termes d'une suite ;
écrire un algorithme de seuil et savoir quand il s'arrête ;
relier ce que fait l'algorithme à ce que tu démontres sur les limites ;
éviter les erreurs qui coûtent des points au bac.

Tu supposes connus le raisonnement par récurrence, la notion de limite d'une suite, ainsi que les théorèmes de comparaison et de convergence monotone.

Ce qu'est un algorithme, et d'où vient le mot

Un algorithme peut s'écrire en français, sous forme graphique dans un organigramme de programmation ⁴, ou dans un langage comme Python. Au lycée, on retient surtout Python : c'est le langage des sujets de bac.

RemarqueUn peu d'histoire

Le mot « algorithme » vient du nom du mathématicien perse Al-Khwârizmî, actif entre 813 et 833 ⁵. Il a systématisé des algorithmes en donnant, dans un ouvrage consacré aux équations, des méthodes générales pour résoudre les équations du second degré, avec des explications là où les Babyloniens se contentaient d'exemples ⁵.

L'idée est pourtant bien plus ancienne : les premières descriptions d'algorithmes retrouvées datent des Babyloniens, au IIIe millénaire avant notre ère ⁵. Chez Euclide, l'algorithme qui calcule le plus grand diviseur commun de deux nombres contient explicitement une itération, c'est-à-dire une répétition ⁵. Le terme latin algorismus est introduit au XIIe siècle par Adélard de Bath, et le mot français « algorithme » apparaît en 1554 ⁵.

Calculer les termes d'une suite avec une boucle

Une suite peut être définie de deux façons. Une définition explicite donne $u_n$ directement en fonction de $n$ : par exemple $u_n = 3n + 2$ . Une définition par récurrence donne le premier terme et une relation qui passe d'un terme au suivant : par exemple $u_0 = 5$ et $u_{n+1} = 0{,}8\,u_n + 2$ .

Pour une suite explicite, calculer $u_n$ ne demande qu'une affectation. Pour une suite définie par récurrence, il faut répéter la relation : c'est exactement le rôle d'une boucle.

MéthodeCalculer $u_n$ pour une suite récurrente (boucle for)

Quand tu connais le rang $n$ voulu, le nombre de répétitions est connu d'avance : utilise une boucle for.

Initialise une variable u avec la valeur de $u_0$ .
Répète $n$ fois l'instruction qui transforme $u_k$ en $u_{k+1}$ .
Renvoie u.

def terme(n):
    u = 5
    for k in range(n):
        u = 0.8 * u + 2
    return u

La variable u est écrasée à chaque tour : elle contient successivement $u_0$ , $u_1$ , $u_2$ , etc. À la sortie de la boucle, elle contient $u_n$ .

Premiers termes de la suite $u_{n+1} = 0{,}8\,u_n + 2$
n	u_n
0	5
1	6
2	6,8
3	7,44
4	7,952
5	8,3616
6	8,68928

Premiers termes de la suite $u_{n+1} = 0{,}8\,u_n + 2$ · La suite est croissante et semble se rapprocher de 10.

RemarqueObtenir toute la liste des termes

Les ressources de cycle terminal citent explicitement l'obtention d'une liste de termes d'une suite parmi les algorithmes à pratiquer ². En Python, on ajoute chaque terme à une liste :

def liste_termes(n):
    u = 5
    liste = [u]
    for k in range(n):
        u = 0.8 * u + 2
        liste.append(u)
    return liste

Cette liste sert à conjecturer : tu y repères si la suite semble croissante, bornée, ou se rapprocher d'une valeur.

L'algorithme de seuil

Le grand classique du bac est la recherche d'un seuil : le plus petit entier $n$ tel que $u_n$ dépasse une valeur donnée $S$ . Ici le nombre de répétitions n'est pas connu à l'avance. On utilise donc une boucle while (« tant que »), qui s'arrête quand la condition cesse d'être vraie.

Initialisern = 0 et u = valeur de u0
Testerwhile : on continue tant que le seuil n'est pas atteint
Avancercalculer le terme suivant, puis n = n + 1
Renvoyerreturn n : le rang, pas la valeur de u

Les étapes d'un algorithme de seuil

ExempleCapital placé à 10 % par an

Soit $u_0 = 1000$ et $u_{n+1} = 1{,}1\,u_n$ . On cherche le plus petit $n$ tel que $u_n > 2000$ .

def seuil(S):
    n = 0
    u = 1000
    while u <= S:
        u = 1.1 * u
        n = n + 1
    return n

En suivant l'exécution pour $S = 2000$ :

$n$	0	1	2	3	4	5	6	7	8
$u_n$	1000	1100	1210	1331	1464,1	1610,51	1771,561	1948,7171	2143,58881

Jusqu'à $n = 7$ , on a $u_n \leq 2000$ et la boucle continue ; pour $n = 8$ , $u_8 > 2000$ et la boucle s'arrête. L'appel seuil(2000) renvoie 8.

On peut retrouver ce résultat par le calcul. Comme $u_n = 1000 \times 1{,}1^n$ , l'inéquation $u_n > 2000$ équivaut à $1{,}1^n > 2$ , soit $n \ln(1{,}1) > \ln 2$ , donc $n > \dfrac{\ln 2}{\ln 1{,}1} \approx 7{,}27$ . Le plus petit entier convenable est 8. L'algorithme et le calcul se confirment : au bac, on te demande souvent l'un puis l'autre.

Quand l'algorithme s'arrête-t-il ?

Un algorithme avec une boucle while peut ne jamais s'arrêter. C'est le point théorique le plus important de ce chapitre, car il fait le lien avec les limites.

Démonstration · Pourquoi la boucle se termine

Soit $S$ un réel. L'intervalle $]S\,;\,+\infty[$ contient tous les termes de la suite à partir d'un certain rang $N$ , puisque $u_n \to +\infty$ . Autrement dit, $u_N > S$ . Dans l'algorithme, n prend successivement les valeurs $0, 1, 2, \dots$ et u vaut $u_n$ . Dès que n atteint (au plus) $N$ , la condition u <= S devient fausse et la boucle s'arrête. Comme les rangs sont testés dans l'ordre $0, 1, 2, \dots$ , la boucle s'arrête au premier rang où $u_n > S$ : le résultat renvoyé est donc bien le plus petit rang cherché. La croissance assure en plus que tous les rangs suivants vérifient encore $u_n > S$ .

Approcher une limite : l'algorithme de précision

Pour une suite convergente, la question change de forme : on cherche à partir de quel rang les termes sont proches de la limite $\ell$ à une précision $\varepsilon$ donnée. Les ressources de l'IREM consacrées aux suites insistent sur la définition de la limite par des intervalles : à partir d'un certain rang, tous les termes sont dans l'intervalle considéré ³. L'algorithme met cette idée en pratique : on fixe un petit intervalle autour de $\ell$ et on cherche le rang d'entrée.

ExemplePrécision sur $u_0 = 5$, $u_{n+1} = 0{,}8\,u_n + 2$

On admet pour l'instant que la limite est 10. On cherche le plus petit $n$ tel que $|10 - u_n| < 0{,}01$ .

def rang_precision(eps):
    n = 0
    u = 5
    while abs(10 - u) >= eps:
        u = 0.8 * u + 2
        n = n + 1
    return n

Ici encore, la condition du while est l'inverse de l'objectif : on veut abs(10 - u) < eps, on continue tant que abs(10 - u) >= eps. L'appel rang_precision(0.01) renvoie 28.

Démonstration · Expression explicite et vérification de 28

Étape 1 : expression explicite. Montrons par récurrence que, pour tout entier $n$ , $u_n = 10 - 5 \times 0{,}8^n$ .

Initialisation : pour $n = 0$ , $10 - 5 \times 1 = 5 = u_0$ .
Hérédité : supposons $u_n = 10 - 5 \times 0{,}8^n$ . Alors $u_{n+1} = 0{,}8\,(10 - 5 \times 0{,}8^n) + 2 = 8 - 5 \times 0{,}8^{n+1} + 2 = 10 - 5 \times 0{,}8^{n+1}$ .
Conclusion : la propriété est vraie pour tout $n$ .

Étape 2 : limite. Comme $-1 < 0{,}8 < 1$ , $0{,}8^n \to 0$ , donc $u_n \to 10$ . De plus $10 - u_n = 5 \times 0{,}8^n > 0$ : la suite reste strictement sous 10, ce qui explique la boucle infinie du paragraphe précédent pour $S = 12$ .

Étape 3 : précision. $|10 - u_n| < 0{,}01$ équivaut à $5 \times 0{,}8^n < 0{,}01$ , soit $0{,}8^n < 0{,}002$ , donc $n \ln 0{,}8 < \ln 0{,}002$ . Comme $\ln 0{,}8 < 0$ , on divise en renversant l'inégalité : $n > \dfrac{\ln 0{,}002}{\ln 0{,}8} \approx 27{,}85$ . Le plus petit entier est 28, ce que l'algorithme avait renvoyé.

Algorithme, conjecture et démonstration

Un algorithme calcule ; il ne démontre rien. Si terme(1000) renvoie une valeur proche de 10, tu as une bonne raison de conjecturer que la limite est 10, mais ce n'est pas une preuve. La preuve vient des outils du cours : récurrence pour établir une formule ou un encadrement, théorèmes de comparaison pour une limite, théorème de convergence monotone pour une suite croissante majorée.

ExempleMajoration et sens de variation de la même suite

Pour $u_0 = 5$ et $u_{n+1} = 0{,}8\,u_n + 2$ , démontrons par récurrence que $u_n \leq u_{n+1} \leq 10$ pour tout $n$ .

Initialisation : $u_0 = 5 \leq u_1 = 6 \leq 10$ .
Hérédité : on suppose $u_n \leq u_{n+1} \leq 10$ . En multipliant par $0{,}8 > 0$ puis en ajoutant 2, on conserve l'ordre : $0{,}8\,u_n + 2 \leq 0{,}8\,u_{n+1} + 2 \leq 0{,}8 \times 10 + 2$ , soit $u_{n+1} \leq u_{n+2} \leq 10$ .
Conclusion : la suite est croissante et majorée par 10.

Le théorème de convergence monotone assure alors qu'elle converge. Ce résultat est cohérent avec l'expression explicite et avec ce que l'algorithme laissait deviner.

Erreurs fréquentes et bonnes habitudes

Les documents d'accompagnement recommandent de donner aux élèves de bonnes habitudes de rigueur lors de l'écriture d'algorithmes et de programmes ². Voici une liste de contrôle à parcourir avant de rendre une copie.

Exercices corrigés

Exercice 1 Calculer un terme avec une boucle

★☆☆Environ 8 min

On considère la suite définie par $u_0 = 5$ et, pour tout entier naturel $n$ , $u_{n+1} = 0{,}8\,u_n + 2$ .

Écris une fonction Python terme(n) qui renvoie $u_n$ .
Calcule à la main la valeur renvoyée par terme(3).

Indice 1

Combien de fois la boucle doit-elle s'exécuter pour passer de $u_0$ à $u_3$ ?

Indice 2

Applique la relation successivement : $u_1$ , puis $u_2$ , puis $u_3$ .

Voir la correction pas à pas

On initialise u à 5 puis on répète n fois l'instruction u = 0.8 * u + 2 dans une boucle for k in range(n), et on renvoie u.
Pour terme(3), la boucle s'exécute trois fois.
Premier tour : $u_1 = 0{,}8 \times 5 + 2 = 6$ .
Deuxième tour : $u_2 = 0{,}8 \times 6 + 2 = 6{,}8$ .
Troisième tour : $u_3 = 0{,}8 \times 6{,}8 + 2 = 7{,}44$ . La fonction renvoie donc 7,44.

Le nombre de tours de boucle est égal à l'indice du terme voulu, puisque le point de départ est $u_0$ .

Exercice 2 Trouver un rang seuil

★★☆Environ 12 min

Une somme de 1000 euros est placée à intérêts composés au taux de 10 % par an. On note $u_n$ le capital après $n$ années : $u_0 = 1000$ et $u_{n+1} = 1{,}1\,u_n$ .

Écris un algorithme qui renvoie le plus petit entier $n$ tel que $u_n > 2000$ .
Détermine ce rang par le calcul, avec la fonction logarithme népérien.

Indice 1

La condition du while est le contraire de l'objectif $u_n > 2000$ .

Indice 2

Exprime $u_n$ en fonction de $n$ : c'est une suite géométrique.

Voir la correction pas à pas

On initialise n = 0 et u = 1000.
On écrit while u <= 2000 : puis, dans la boucle, u = 1.1 * u et n = n + 1.
Après la boucle, on renvoie n.
Par le calcul : $u_n = 1000 \times 1{,}1^n$ , donc $u_n > 2000$ équivaut à $1{,}1^n > 2$ .
On applique le logarithme népérien, croissant : $n \ln 1{,}1 > \ln 2$ . Comme $\ln 1{,}1 > 0$ , $n > \dfrac{\ln 2}{\ln 1{,}1} \approx 7{,}27$ .
Le plus petit entier qui convient est 8 : $u_7 \approx 1948{,}72 \leq 2000$ et $u_8 \approx 2143{,}59 > 2000$ .

Le plus petit rang est $n = 8$ : au bout de 8 ans, le capital dépasse 2000 euros. L'algorithme et le calcul donnent le même résultat.

Exercice 3 Précision d'approximation d'une limite

★★★Environ 18 min

Soit $(u_n)$ définie par $u_0 = 5$ et $u_{n+1} = 0{,}8\,u_n + 2$ .

Démontre par récurrence que, pour tout entier $n$ , $u_n = 10 - 5 \times 0{,}8^n$ .
Déduis-en la limite de $(u_n)$ .
Détermine le plus petit entier $n$ tel que $|10 - u_n| < 0{,}01$ .
Que se passerait-il si on lançait un algorithme de seuil cherchant $u_n > 12$ ?

Indice 1

Pour l'hérédité, remplace $u_n$ par l'expression de l'hypothèse dans la relation de récurrence.

Indice 2

Pour la question 3, utilise $|10 - u_n| = 5 \times 0{,}8^n$ et pense au signe de $\ln 0{,}8$ .

Voir la correction pas à pas

Initialisation : $10 - 5 \times 0{,}8^0 = 5 = u_0$ .
Hérédité : si $u_n = 10 - 5 \times 0{,}8^n$ , alors $u_{n+1} = 0{,}8\,(10 - 5 \times 0{,}8^n) + 2 = 10 - 5 \times 0{,}8^{n+1}$ . La propriété est donc héréditaire, donc vraie pour tout $n$ .
Limite : $-1 < 0{,}8 < 1$ , donc $0{,}8^n \to 0$ et $u_n \to 10$ .
Précision : $10 - u_n = 5 \times 0{,}8^n > 0$ , donc l'inéquation est $5 \times 0{,}8^n < 0{,}01$ , soit $0{,}8^n < 0{,}002$ .
On applique $\ln$ : $n \ln 0{,}8 < \ln 0{,}002$ . Comme $\ln 0{,}8 < 0$ , $n > \dfrac{\ln 0{,}002}{\ln 0{,}8} \approx 27{,}85$ . Le plus petit entier est 28.
Pour le seuil 12 : $u_n < 10 < 12$ pour tout $n$ , donc la condition du while reste vraie indéfiniment et l'algorithme ne s'arrête jamais.

Le rang 28 est le plus petit pour lequel $u_n$ est à moins de 0,01 de 10. Un seuil supérieur à la limite d'une suite croissante convergente provoque une boucle infinie.

Les questions qu'on se pose

Quelle différence entre une boucle for et une boucle while pour les suites ?

Une boucle for s'utilise quand tu connais le nombre de répétitions à l'avance, par exemple pour calculer $u_{20}$ . Une boucle while s'utilise quand tu ne connais pas ce nombre : tu répètes jusqu'à ce qu'une condition change, comme dans la recherche d'un seuil. Dans le doute, demande-toi : « Est-ce que l'énoncé me donne le rang ou me demande de le trouver ? »

Pourquoi la condition du while est-elle l'inverse de ce que je cherche ?

Parce que le while signifie « tant que je dois continuer ». Si tu cherches le premier rang où $u_n > S$ , tu dois continuer tant que $u_n \leq S$ . Écrire la condition de l'objectif, c'est empêcher la boucle de démarrer.

Mon algorithme ne s'arrête pas : que faire ?

Vérifie dans l'ordre : (1) la variable qui sert au test est bien modifiée dans la boucle ; (2) la suite est capable de franchir le seuil, ce qui est faux si le seuil dépasse sa limite ; (3) le sens de l'inégalité est le bon. Sur papier, déroule trois ou quatre tours avec un tableau n / u.

Est-ce qu'un algorithme prouve qu'une suite converge ?

Non. Il calcule un nombre fini de termes et te permet de conjecturer. La preuve repose sur le cours : récurrence pour une expression ou un encadrement, théorèmes de comparaison pour une limite, théorème de convergence monotone pour une suite croissante majorée. Au bac, la conjecture par programme est souvent suivie d'une démonstration.

Faut-il savoir écrire du Python de tête au bac ?

Le plus souvent, on te donne un programme à compléter ou à interpréter. Il faut maîtriser l'affectation, la boucle for, la boucle while, les opérateurs de comparaison et le return. Les documents d'accompagnement évoquent aussi la description d'algorithmes en langage naturel ou avec un tableur ² : sois à l'aise avec ces formes.

Sources

Document Éduscol — Ressources d'accompagnement (Terminale), Éduscol. Consulté le 6 novembre 2026.
Diaporama algorithmique — Lycée, Académie de Strasbourg. Consulté le 6 novembre 2026.
Ressources IREM — Suites et algorithmes, IREM de Limoges. Consulté le 6 novembre 2026.
Algorithme, Wikipédia. Consulté le 6 novembre 2026.
Algorithmique, Wikipédia. Consulté le 6 novembre 2026.

Les numéros dans le texte renvoient à ces sources. Une source qui ne dit pas ce qu'on lui fait dire ? Signale-le.

Signaler une erreur sur cette page

Suites et algorithmes : cours de Terminale spécialité maths

L'essentiel

Pourquoi associer suites et algorithmes

Ce qu'est un algorithme, et d'où vient le mot

Calculer les termes d'une suite avec une boucle

L'algorithme de seuil

Quand l'algorithme s'arrête-t-il ?

Approcher une limite : l'algorithme de précision

Algorithme, conjecture et démonstration

Erreurs fréquentes et bonnes habitudes

Exercices corrigés

Exercice 1 Calculer un terme avec une boucle

Exercice 2 Trouver un rang seuil

Exercice 3 Précision d'approximation d'une limite

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur