Mathématiques (spécialité) · PremièreÉpreuve anticipée de mathématiques

Algorithmes sur les suites : cours de Première spécialité maths

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

L'essentiel

Une suite se programme avec une boucle for : on part de $u_0$ et on applique la relation de récurrence autant de fois que nécessaire (n passages pour atteindre $u_n$ ).
Avec une formule explicite, pas de boucle : une seule ligne calcule directement $u_n$ ; la boucle sert quand la suite est donnée par récurrence.
Pour une liste des termes, on ajoute chaque valeur avec append ou on utilise une compréhension de liste ; pour une somme, on utilise un accumulateur initialisé à 0.
Pour un seuil, le nombre de passages n'est pas connu d'avance : on utilise une boucle while qui s'arrête dès que la condition est atteinte.
Un algorithme se teste à la main avec un tableau de suivi des variables, et on contrôle toujours le premier et le dernier tour (erreurs « décalées d'un cran »).

Pourquoi programmer des suites ?

Une suite, c'est une liste de nombres rangés dans un ordre précis : $u_0$ , $u_1$ , $u_2$ , et ainsi de suite. En Première, tu en as étudié plusieurs modes de définition, et tu sais calculer à la main les premiers termes. Mais que faire si on te demande $u_{200}$ , ou le premier terme qui dépasse un million ? À la main, c'est interminable. Un ordinateur, lui, répète une même opération des milliers de fois sans se fatiguer. C'est tout l'intérêt de ce chapitre : traduire une suite en programme Python.

Le programme de Première place d'ailleurs les suites parmi les grands thèmes où l'on modélise et où l'on représente des situations ¹. Et les ressources académiques proposent de mettre en place les différents modes de génération d'une suite, avec un algorithme dès qu'il faut résoudre un problème de seuil ³. Tu vas donc retrouver ces idées tout au long du chapitre.

Un algorithme peut se présenter sous plusieurs formes : en phrases, sous forme graphique (un organigramme) ⁴, ou directement dans un langage de programmation. Dans ce cours, on écrit directement en Python, car c'est le langage que tu utilises au lycée. Au cycle 4, l'algorithmique avait déjà pour but de développer la pensée algorithmique et la résolution de problèmes, pas de former des experts ² : tu n'as donc rien de nouveau à craindre, il s'agit surtout de bien organiser tes idées.

Les deux façons de définir une suite, et ce que cela change pour le programme

Avant de programmer, rappelons comment une suite peut être donnée. Cela décide du type de programme à écrire.

Par une formule explicite : $u_n = f(n)$ . Pour connaître $u_{20}$ , on remplace $n$ par $20$ .
Par une relation de récurrence : on donne le premier terme et une règle qui fait passer d'un terme au suivant, par exemple $u_0 = 3$ et $u_{n+1} = 2u_n + 1$ . Pour connaître $u_{20}$ , il faut en principe connaître $u_{19}$ , qui lui-même demande $u_{18}$ , etc.

Ces deux modes font partie de ceux que les ressources d'accompagnement invitent à faire manipuler aux élèves ³.

RepérerFormule explicite ou récurrence ?
InitialiserPremier terme, accumulateur, compteur n
Choisir la bouclefor si n connu, while pour un seuil
Mettre à jourTerme suivant, somme, compteur
TesterCas n = 0 et cas calculé à la main

Choisir son algorithme sur une suite · Démarche générale pour programmer une suite.

Calculer un terme avec une boucle for

C'est le cas le plus courant en récurrence. L'idée est de garder dans une variable u la valeur du terme « courant », puis de la remplacer par le terme suivant à chaque tour de boucle.

MéthodeProgrammer le calcul de $u_n$

Initialiser la variable avec le premier terme ( $u_0$ ).
Répéter n fois la règle de passage au terme suivant, avec for k in range(n):.
À la fin de la boucle, la variable contient $u_n$ ; la renvoyer avec return.

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

Avec terme(4), on obtient 63, comme dans le calcul à la main.

Le point qui déroute le plus : la ligne u = 2 * u + 1 n'est pas une équation. Le signe = de Python signifie « range dans la variable de gauche le résultat du calcul de droite ». Python calcule d'abord 2 * u + 1 avec l'ancienne valeur de u, puis range le résultat dans u. L'ancienne valeur disparaît : on ne conserve que le terme courant.

Tableau de suivi de terme(4)
Moment	k	u
Avant la boucle	—	3
Tour 1	0	7
Tour 2	1	15
Tour 3	2	31
Tour 4	3	63

Tableau de suivi de terme(4) · À la fin de la boucle, u contient u_4 = 63.

Ce tableau s'appelle un tableau de suivi (ou trace d'exécution). Il liste, tour après tour, la valeur de chaque variable. C'est l'outil qui permet de comprendre un programme sans l'exécuter, et il est très utile en contrôle : on te demandera souvent de « faire fonctionner l'algorithme à la main ».

ExempleUne suite dépendant de $n$

Soit $(v_n)$ définie par $v_0 = 1$ et $v_{n+1} = v_n + 2n + 1$ . La règle utilise aussi $n$ . Dans la boucle, la variable k joue ce rôle : quand on passe de $v_k$ à $v_{k+1}$ , on ajoute $2k+1$ .

def terme_v(n):
    v = 1
    for k in range(n):
        v = v + 2 * k + 1
    return v

À la main : $v_1 = 1 + 1 = 2$ , $v_2 = 2 + 3 = 5$ , $v_3 = 5 + 5 = 10$ . Le programme renvoie bien terme_v(3) = 10. On remarque que k vaut le rang du terme avant le passage : c'est ce qui explique le « $2k+1$ » et non « $2(k+1)+1$ ».

Utiliser une formule explicite

Quand la suite est donnée par une formule explicite, aucune boucle n'est nécessaire : la fonction traduit simplement la formule.

Pour notre suite $u_0 = 3$ , $u_{n+1} = 2u_n + 1$ , on peut démontrer que $u_n = 4 \times 2^n - 1$ . Vérifions : $u_0 = 4 \times 1 - 1 = 3$ et $u_4 = 4 \times 16 - 1 = 63$ , ce qui correspond.

def terme_explicite(n):
    return 4 * 2 ** n - 1

En Python, la puissance s'écrit ** et non ^.

Démonstration · Pourquoi $u_n = 4 \times 2^n - 1$ ?

Ajoutons $1$ aux deux membres de la relation : $u_{n+1} + 1 = 2u_n + 2 = 2(u_n + 1)$ . La suite $(u_n + 1)$ est donc géométrique de raison $2$ et de premier terme $u_0 + 1 = 4$ . Ainsi $u_n + 1 = 4 \times 2^n$ , d'où $u_n = 4 \times 2^n - 1$ .

Construire la liste des termes

Pour tracer un nuage de points, repérer le sens de variation ou chercher un motif, on veut parfois tous les termes jusqu'à un rang donné. On les range alors dans une liste. Il y a deux façons de faire, que tu connais grâce aux listes en Python.

MéthodePremière méthode : append

Créer une liste qui contient le premier terme.
À chaque tour de boucle, calculer le terme suivant et l'ajouter avec append.

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

L'appel liste_termes(5) renvoie [3, 7, 15, 31, 63, 127]. La liste contient n + 1 valeurs, de $u_0$ à $u_n$ : le premier terme est ajouté avant la boucle.

MéthodeSeconde méthode : compréhension de liste (suite explicite)

Si on dispose de la formule explicite, une compréhension de liste fait le travail en une ligne :

[4 * 2 ** k - 1 for k in range(6)]

Cette instruction renvoie la même liste [3, 7, 15, 31, 63, 127]. Ici range(6) fait varier k de $0$ à $5$ , donc la liste va de $u_0$ à $u_5$ .

ExempleLes motifs en billes

Une ressource académique sur les suites propose un exemple géométrique : le premier motif demande 2 billes, le deuxième 6, le troisième 12, et le suivant 20 ³. On observe que $2 = 1 \times 2$ , $6 = 2 \times 3$ , $12 = 3 \times 4$ et $20 = 4 \times 5$ : le motif numéro $n$ semble demander $n(n+1)$ billes.

On peut faire afficher les premiers nombres de billes par une compréhension :

[n * (n + 1) for n in range(1, 6)]

Ce qui donne [2, 6, 12, 20, 30]. Ici la suite commence au rang $1$ , donc range(1, 6) : le premier rang est inclus, le dernier ( $6$ ) est exclu.

Calculer une somme de termes

Autre besoin classique : additionner les termes $u_0 + u_1 + \dots + u_n$ . On utilise un accumulateur, c'est-à-dire une variable qui part de $0$ et à laquelle on ajoute chaque terme au fur et à mesure.

Pour la suite de notre exemple :

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

Ici, s est initialisée avec $u_0 = 3$ parce que le premier terme fait partie de la somme et qu'il n'est pas ajouté dans la boucle. Pour n = 3, on trouve $3 + 7 + 15 + 31 = 56$ .

MéthodeUne version plus sûre : sommer à chaque tour

Pour éviter l'oubli du premier terme, on peut initialiser s à 0 et ajouter chaque terme, y compris le premier, avant de calculer le suivant :

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

Ici la boucle fait $n+1$ passages : un par terme à additionner. Remarque que l'on calcule en passant un terme de trop à la fin (la dernière valeur de u n'est pas ajoutée), ce qui est sans conséquence sur le résultat.

ExempleSomme des termes d'une suite arithmétique

Soit $(v_n)$ définie par $v_0 = 5$ et $v_{n+1} = v_n + 3$ . On veut $S = v_0 + v_1 + \dots + v_{10}$ .

v = 5
s = 0
for k in range(11):
    s = s + v
    v = v + 3
print(s)

Le programme affiche 220. Contrôle par le calcul : $v_n = 5 + 3n$ donc $v_{10} = 35$ , et la somme de 11 termes consécutifs d'une suite arithmétique vaut $\frac{11 \times (5 + 35)}{2} = 220$ .

Chercher un seuil avec une boucle while

Jusqu'ici, on connaissait le nombre de tours à l'avance : c'était $n$ . Mais une question comme « à partir de quel rang la suite dépasse-t-elle 1 000 ? » ne donne pas ce nombre. Il faut s'arrêter dès que la condition est vérifiée. C'est le rôle de la boucle while (« tant que »).

Les ressources académiques mentionnent justement qu'un algorithme permet de résoudre ce type de problème de seuil ³, et elles le rencontrent aussi dans un contexte financier : déterminer le nombre de mensualités d'un prêt ³. Le chapitre suivant (méthode de seuil et de balayage) approfondira cette technique ; voici déjà le principe de base.

MéthodeÉcrire un algorithme de seuil

Initialiser le rang n à $0$ et la variable u au premier terme.
Écrire la condition tant que : on continue tant que le seuil n'est pas atteint.
Dans la boucle, passer au terme suivant et augmenter n de 1.
À la sortie de la boucle, n est le plus petit rang pour lequel la condition cherchée est vérifiée.

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

Pour seuil(1000), on obtient 8. Contrôle : $u_7 = 4 \times 128 - 1 = 511$ qui est inférieur à $1000$ , et $u_8 = 4 \times 256 - 1 = 1023$ qui le dépasse.

Tester, vérifier, utiliser un tableau de suivi

Un programme qui s'exécute sans message d'erreur n'est pas forcément un programme correct. Il peut calculer autre chose que ce qu'on voulait, comme une valeur décalée d'un rang. Avec des suites, trois contrôles suffisent la plupart du temps.

Les algorithmes sont puissants, mais ils exécutent exactement ce qu'on leur écrit, rien de plus. Ils sont d'ailleurs conçus par des personnes et ne sont pas neutres par nature : leurs choix de conception pèsent sur leurs résultats ⁴. À notre échelle, cela veut dire une chose très simple : c'est à toi de vérifier que le programme répond bien à la question posée.

Les erreurs fréquentes, à connaître avant l'épreuve

ExempleUn programme faux à corriger

On voudrait calculer $u_5$ pour $u_0 = 3$ et $u_{n+1} = 2u_n + 1$ :

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

Le return est dans la boucle. Au premier tour, la fonction renvoie 7 et s'arrête, quelle que soit la valeur de n (supérieure ou égale à 1). Il suffit de décaler return u pour le placer après la boucle, au même niveau que le for.

Exercices corrigés

Exercice 1 Calculer un terme par récurrence

★☆☆Environ 8 min

On considère la suite $(u_n)$ définie par $u_0 = 2$ et $u_{n+1} = 3u_n - 1$ .

Calcule à la main $u_1$ , $u_2$ et $u_3$ .
Complète le programme pour qu'il renvoie $u_n$ :

def terme(n):
    u = ...
    for k in range(...):
        u = ...
    return u

Quelle valeur renvoie terme(5) ?

Indice 1

Pour passer de $u_0$ à $u_5$ , combien de fois applique-t-on la règle ?

Indice 2

Fais un tableau de suivi avec les colonnes k et u.

Voir la correction pas à pas

Calcul à la main : $u_1 = 3 \times 2 - 1 = 5$ , puis $u_2 = 3 \times 5 - 1 = 14$ , puis $u_3 = 3 \times 14 - 1 = 41$ .
Initialisation : la variable u prend le premier terme, donc u = 2.
Nombre de tours : on applique la règle $n$ fois pour aller de $u_0$ à $u_n$ , donc range(n).
Instruction dans la boucle : u = 3 * u - 1.
Calcul de $u_5$ en poursuivant : $u_4 = 3 \times 41 - 1 = 122$ , puis $u_5 = 3 \times 122 - 1 = 365$ .

terme(5) renvoie 365. Le programme complet est u = 2, range(n), u = 3 * u - 1.

Exercice 2 Somme de termes d'une suite arithmétique

★★☆Environ 10 min

Soit $(v_n)$ la suite définie par $v_0 = 4$ et $v_{n+1} = v_n + 5$ .

v = 4
s = 0
for k in range(21):
    s = s + v
    v = v + 5

Quels termes sont additionnés dans s à la fin de ce programme ?
Donne la formule explicite de $v_n$ .
Quelle est la valeur finale de s ?

Indice 1

La boucle fait 21 passages et additionne la valeur courante avant de la modifier.

Indice 2

Une suite arithmétique de raison $r$ vérifie $v_n = v_0 + nr$ .

Voir la correction pas à pas

Le programme ajoute v à s puis calcule le terme suivant. Au premier tour, il ajoute $v_0$ ; au dernier (21e tour), il ajoute $v_{20}$ . Donc s $= v_0 + v_1 + \dots + v_{20}$ , soit 21 termes.
La suite est arithmétique de raison $5$ : $v_n = 4 + 5n$ .
Dernier terme additionné : $v_{20} = 4 + 5 \times 20 = 104$ .
Somme de termes consécutifs : $S = \frac{21 \times (4 + 104)}{2} = \frac{21 \times 108}{2} = 1134$ .
Contrôle : $21 \times 4 = 84$ et $5 \times (0 + 1 + \dots + 20) = 5 \times 210 = 1050$ , d'où $84 + 1050 = 1134$ .

La valeur finale de s est 1134. Remarque que le dernier terme calculé dans v ( $v_{21} = 109$ ) n'est jamais ajouté : c'est sans conséquence sur la somme.

Exercice 3 Trouver un seuil pour une suite géométrique

★★☆Environ 10 min

Une quantité vaut 500 au départ et double à chaque étape : $w_0 = 500$ et $w_{n+1} = 2w_n$ .

Écris une fonction rang_depasse(S) qui renvoie le plus petit entier $n$ tel que $w_n > S$ .
Donne la valeur renvoyée pour $S = 100\,000$ .

Indice 1

Utilise une boucle while dont la condition est w <= S.

Indice 2

Le terme général est $w_n = 500 \times 2^n$ : cherche la plus petite puissance de 2 supérieure à $200$ .

Voir la correction pas à pas

Initialisation : n = 0 et w = 500.
Boucle : while w <= S: puis w = 2 * w et n = n + 1. À la sortie, return n.
Calcul à la main : on cherche $500 \times 2^n > 100\,000$ , soit $2^n > 200$ .
Puissances de 2 : $2^7 = 128$ (trop petit) et $2^8 = 256$ (suffisant).
Contrôle avec la suite : $w_7 = 500 \times 128 = 64\,000 \leq 100\,000$ et $w_8 = 500 \times 256 = 128\,000 > 100\,000$ .

La fonction renvoie 8 pour $S = 100\,000$ . Le rang trouvé est celui du premier terme qui dépasse le seuil.

Exercice 4 Les motifs de billes

★★★Environ 15 min

Dans un exemple de ressource académique, le premier motif en billes en demande 2, le deuxième 6, le troisième 12 et le quatrième 20 ³. On admet que le motif numéro $n$ demande $u_n = n(n+1)$ billes.

Vérifie cette formule sur les quatre motifs donnés.
Écris un programme qui renvoie le numéro du premier motif nécessitant strictement plus de 300 billes.
Quel numéro obtient-on ?

Indice 1

La suite commence au rang $1$ : initialise n = 1.

Indice 2

Teste les valeurs $16 \times 17$ et $17 \times 18$ .

Voir la correction pas à pas

Vérification : $1 \times 2 = 2$ , $2 \times 3 = 6$ , $3 \times 4 = 12$ , $4 \times 5 = 20$ . La formule correspond aux quatre motifs.
Programme : n = 1, puis while n * (n + 1) <= 300: et n = n + 1 dans la boucle, puis print(n).
À la main : $16 \times 17 = 272$ , qui est inférieur à $300$ , donc la boucle continue.
Au tour suivant : $17 \times 18 = 306$ , qui dépasse $300$ , donc la boucle s'arrête avec n = 17.
Contrôle algébrique : $n(n+1) > 300$ équivaut à $n^2 + n - 300 > 0$ , dont la racine positive vaut environ $16{,}8$ , donc le plus petit entier convenable est $17$ .

Le premier motif qui demande plus de 300 billes est le motif numéro 17 (306 billes).

Quiz

8 questions · correction immédiate · ton score reste sur ton appareil.

On exécute :
```
u = 3
for k in range(3):
    u = 2 * u + 1
```
Quelle est la valeur finale de u ?
Ta réponse
Trois passages : $3 \to 7 \to 15 \to 31$ . La valeur finale est $u_3 = 31$ . Répondre $15$ revient à ne faire que deux tours, et répondre $63$ à en faire quatre : il faut compter exactement le nombre de passages de range(3).
Pour calculer $u_n$ à partir de $u_0$ avec une relation de récurrence, la boucle for doit faire :
$n$ passages $n+1$ passages $n-1$ passagesun nombre de passages qui dépend de la valeur de $u_0$
Un algorithme est une suite finie d'instructions précises et sans ambiguïté, qui permet de résoudre toute une famille de problèmes.
VraiFaux
Que renvoie l'instruction [3 * k + 1 for k in range(4)] ?
[1, 4, 7, 10][4, 7, 10, 13][1, 4, 7][0, 3, 6, 9]
On veut trouver le premier rang $n$ pour lequel $u_n > S$ . Quelle structure choisir ?
Une boucle while u <= SUne boucle while u > SUne boucle for k in range(S)Une simple fonction avec return
Une suite arithmétique est donnée par $u_n = 2n$ . Quelle est la somme $u_0 + u_1 + u_2 + u_3 + u_4$ ?
Ta réponse
Quelles affirmations sont correctes ? (plusieurs réponses possibles)

Plusieurs réponses possibles.
Une somme se prépare avec un accumulateur initialisé à 0u = 2 * u + 1 est une équation que Python doit résoudreAvec une formule explicite, aucune boucle n'est nécessaire pour calculer $u_n$ En Python, 2 ^ 3 calcule $2^3$
Pour une suite définie par une formule explicite, il faut obligatoirement une boucle pour calculer $u_{100}$ .
VraiFaux

Les questions qu'on se pose

Pourquoi écrit-on range(n) et pas range(n+1) pour calculer u_n ?

Parce que la boucle part déjà de $u_0$ , qui est donné par l'initialisation. Pour atteindre $u_n$ , il reste $n$ passages à faire. La confusion vient de l'idée qu'il y a « $n+1$ termes » : c'est vrai pour la liste de $u_0$ à $u_n$ , mais pas pour le nombre d'opérations à effectuer. Le test de n = 0 est un bon réflexe : aucun passage ne doit avoir lieu.

Quelle différence entre for et while ?

Avec for, tu connais le nombre de tours avant de commencer (par exemple $n$ ). Avec while, tu répètes tant qu'une condition est vraie, sans savoir combien de tours seront nécessaires, ce qui convient aux problèmes de seuil ³. Si tu hésites, demande-toi : « puis-je dire combien de fois je répète ? ».

Mon programme tourne sans s'arrêter, que faire ?

C'est presque toujours une boucle while dont la condition ne devient jamais fausse. Vérifie trois choses : la variable est bien mise à jour dans la boucle, la condition est dans le bon sens, et la suite atteint vraiment le seuil (une suite décroissante ne dépassera jamais un seuil élevé). Pour le tester, fais un tableau de suivi sur les trois ou quatre premiers tours.

Comment savoir si mon algorithme est correct ?

Teste le plus petit cas ( $n = 0$ ), compare avec des termes calculés à la main, et si possible avec une formule explicite ou une formule de somme. Un tableau de suivi permet aussi de « jouer le rôle de l'ordinateur ». Un programme qui ne produit pas d'erreur n'est pas pour autant juste : l'erreur la plus courante reste le décalage d'un rang.

Pourquoi ne pas utiliser toujours la formule explicite ?

Parce qu'elle n'existe pas toujours, ou qu'elle n'est pas connue : beaucoup de suites sont données seulement par récurrence. Quand les deux existent, on peut les comparer pour vérifier son travail. La boucle reste le moyen général ; la formule est un raccourci quand on la possède.

Sources

Programmes et ressources en mathématiques — voie générale et technologique, Éduscol. Consulté le 6 novembre 2026.
Algorithmique et programmation — Informer et accompagner, Éduscol. Consulté le 6 novembre 2026.
Modéliser et Représenter — Ressource académique, Ressources Académiques. Consulté le 6 novembre 2026.
Algorithme, Wikipédia. Consulté le 6 novembre 2026.
Algorithme D*, 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

Algorithmes sur les suites : cours de Première spécialité maths

L'essentiel

Pourquoi programmer des suites ?

Les deux façons de définir une suite, et ce que cela change pour le programme

Calculer un terme avec une boucle for

Utiliser une formule explicite

Construire la liste des termes

Calculer une somme de termes

Chercher un seuil avec une boucle while

Tester, vérifier, utiliser un tableau de suivi

Les erreurs fréquentes, à connaître avant l'épreuve

Exercices corrigés

Exercice 1 Calculer un terme par récurrence

Exercice 2 Somme de termes d'une suite arithmétique

Exercice 3 Trouver un seuil pour une suite géométrique

Exercice 4 Les motifs de billes

Quiz

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur

Tour	n	u	u ≤ 50 ?
avant	0	3	oui
1	1	7	oui
2	2	15	oui
3	3	31	oui
4	4	63	non