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

Algorithmes sur les suites : exercices corrigés de 1re spécialité

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

L'essentiel

Une suite se programme avec une boucle for quand le nombre de termes est connu, avec une boucle while quand on cherche un seuil.
Pour une suite récurrente, on met à jour une variable ; pour garder tous les termes, on les range dans une liste.
Une compréhension de liste construit en une ligne les termes d'une suite définie par une formule explicite.
Dans un seuil, la condition du while est la négation de ce qu'on cherche, et le compteur donne le rang cherché.
Toujours contrôler l'algorithme en calculant à la main les deux ou trois premiers termes.

Comment utiliser ces exercices

Un algorithme est une suite finie d'instructions, sans ambiguïté, qui permet de résoudre toute une famille de problèmes.⁴ Appliqué aux suites, il sert à calculer un terme, à fabriquer la liste des premiers termes ou à trouver à partir de quel rang une suite franchit une valeur donnée. Les programmes de la voie générale placent d'ailleurs les suites parmi les thèmes où l'on modélise et où l'on représente des situations.¹

Ces exercices supposent que tu sais déjà manipuler une liste en Python et écrire une compréhension de liste. Ils sont classés par difficulté croissante : les trois premiers (niveau 1) travaillent le calcul de termes, les suivants (niveau 2) introduisent les seuils et la détection d'une nature de suite, les derniers (niveau 3) combinent plusieurs idées.

Les exercices

Exercice 1 Calculer un terme avec une boucle for

★☆☆Environ 8 min

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

On propose le script suivant, dont une ligne est à compléter :

u = 5
for i in range(10):
    u = ...
print(u)

Quelle instruction doit remplacer les points de suspension ?
Quelle valeur le script affiche-t-il ?
Quel terme de la suite cette valeur représente-t-elle ?

Indice 1

Chaque passage dans la boucle fait passer d'un terme au suivant.

Indice 2

Compte le nombre de passages dans la boucle : range(10) en donne dix.

Voir la correction pas à pas

On lit la relation de récurrence : pour passer d'un terme au suivant, on ajoute 3. L'instruction est donc u = u + 3.
On compte les passages : range(10) répète la boucle dix fois, en partant de $u_0$ . Après le premier passage, u vaut $u_1$ ; après le dixième, u vaut $u_{10}$ .
On vérifie avec les premiers termes : $u_1 = 8$ , $u_2 = 11$ , $u_3 = 14$ . On ajoute 3 à chaque passage, donc après dix passages on a ajouté $10 \times 3 = 30$ au terme de départ.
On calcule : $u_{10} = 5 + 30 = 35$ . Le script affiche 35.

La suite est arithmétique de raison 3, donc $u_n = 5 + 3n$ et $u_{10} = 35$ . Le nombre de tours de boucle est égal au rang visé quand on part de $u_0$ .

Exercice 2 Construire la liste des premiers termes

★☆☆Environ 10 min

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

Écris un script Python qui construit la liste L contenant $u_0, u_1, \dots, u_7$ en utilisant L.append.
Donne les huit termes de cette liste.
Quelle est la valeur de $u_7$ ?

Indice 1

Commence par L = [3], puis ajoute à chaque tour un terme calculé à partir du dernier élément de la liste, L[-1].

Indice 2

Il faut sept ajouts pour passer de la liste $[u_0]$ à la liste $[u_0, \dots, u_7]$ .

Voir la correction pas à pas

On initialise la liste avec le premier terme : L = [3].
On écrit la boucle : for i in range(7): L.append(2 * L[-1] - 1). Sept passages ajoutent $u_1$ à $u_7$ derrière $u_0$ .
On calcule à la main pour contrôler : $u_1 = 2 \times 3 - 1 = 5$ , $u_2 = 9$ , $u_3 = 17$ , $u_4 = 33$ , $u_5 = 65$ , $u_6 = 129$ , $u_7 = 257$ .
On lit le résultat : L vaut [3, 5, 9, 17, 33, 65, 129, 257] et $u_7 = 257$ .

On remarque que $u_n - 1$ double à chaque rang : $u_n = 2^{n+1} + 1$ , ce qui donne $u_7 = 2^8 + 1 = 257$ . Garder la liste complète permet ensuite de repérer des régularités.

Exercice 3 Somme de termes avec une compréhension de liste

★☆☆Environ 8 min

Pour tout entier naturel $n$ , on pose $u_n = 3n + 2$ .

Écris en une seule ligne une compréhension de liste qui donne $[u_0, u_1, \dots, u_9]$ .
Écris l'instruction qui calcule la somme $S = u_0 + u_1 + \dots + u_9$ .
Calcule $S$ et vérifie ton résultat par une formule.

Indice 1

La formule est explicite : pas besoin de mémoriser le terme précédent, on remplace directement $n$ .

Indice 2

La fonction sum additionne tous les éléments d'une liste.

Voir la correction pas à pas

On écrit la liste : [3 * n + 2 for n in range(10)]. La variable n prend les valeurs de 0 à 9.
On additionne : S = sum([3 * n + 2 for n in range(10)]).
On calcule à la main : les termes vont de $u_0 = 2$ à $u_9 = 29$ et forment une suite arithmétique de dix termes.
On applique la formule « nombre de termes × (premier + dernier) ÷ 2 » : $S = 10 \times (2 + 29) \div 2 = 155$ . Le script et la formule concordent.

Une compréhension de liste convient dès que la suite est donnée par une formule explicite. Le contrôle par une formule est un bon réflexe : si les deux résultats diffèrent, le décalage de range est le premier suspect.

Exercice 4 Premier rang où des billes dépassent un seuil

★★☆Environ 15 min

On construit des motifs avec des billes. Le premier motif utilise 2 billes, le deuxième 6, le troisième 12, le quatrième 20.³ On note $u_n$ le nombre de billes du motif numéro $n$ , avec $n \geqslant 1$ .

Vérifie que la formule $u_n = n(n+1)$ est cohérente avec les quatre motifs donnés.
Écris un algorithme qui détermine le plus petit rang $n$ tel que $u_n > 500$ .
Quelle valeur de $n$ obtient-on ?

Indice 1

Un problème de seuil se résout naturellement avec une boucle while, qu'on arrête dès que la condition est atteinte.³

Indice 2

La condition de la boucle est le contraire de ce qu'on cherche : on continue tant que $u_n \leqslant 500$ .

Voir la correction pas à pas

On teste la formule : $1 \times 2 = 2$ , $2 \times 3 = 6$ , $3 \times 4 = 12$ , $4 \times 5 = 20$ . Les quatre valeurs correspondent.
On initialise : n = 1.
On écrit la boucle : while n * (n + 1) <= 500: n = n + 1. Tant que le nombre de billes ne dépasse pas 500, on passe au motif suivant.
On lit le résultat : à la sortie de la boucle, n est le premier rang pour lequel $n(n+1) > 500$ .
On contrôle à la main autour du seuil : $21 \times 22 = 462$ , qui est inférieur à 500, et $22 \times 23 = 506$ , qui est supérieur à 500. Le rang cherché est 22.

Le motif numéro 22 est le premier à demander plus de 500 billes, avec 506 billes. Ici le compteur n sert à la fois de variable de boucle et de réponse.

Exercice 5 Capital placé et seuil

★★☆Environ 15 min

Un capital de 1000 euros est placé à intérêts composés : chaque année, il augmente de 3 %. On note $c_n$ le capital après $n$ années, avec $c_0 = 1000$ .

Exprime $c_{n+1}$ en fonction de $c_n$ .
Écris un algorithme qui renvoie le nombre d'années nécessaires pour que le capital dépasse 1200 euros.
Quel nombre d'années obtient-on ?

Indice 1

Augmenter de 3 % revient à multiplier par 1,03.

Indice 2

Utilise deux variables : le capital c et le nombre d'années n, toutes deux mises à jour dans la boucle.

Voir la correction pas à pas

On traduit la hausse : $c_{n+1} = 1{,}03 \times c_n$ . La suite est géométrique de raison 1,03.
On initialise : c = 1000 et n = 0.
On écrit la boucle : while c <= 1200: c = c * 1.03 puis n = n + 1 à l'intérieur de la boucle.
On suit les valeurs à la main : $c_1 = 1030$ , $c_2 \approx 1060{,}9$ , $c_3 \approx 1092{,}7$ , $c_4 \approx 1125{,}5$ , $c_5 \approx 1159{,}3$ , $c_6 \approx 1194{,}1$ , $c_7 \approx 1229{,}9$ .
Le capital passe au-dessus de 1200 euros au septième passage : le script affiche n = 7.

Il faut 7 ans. Après 6 ans, le capital (environ 1194 euros) reste juste sous le seuil : c'est typiquement le cas où une estimation « à vue » se trompe d'un rang et où l'algorithme protège de l'erreur. Une activité de ce type existe aussi avec des mensualités de prêt : on y demande un algorithme qui détermine le nombre de mensualités.³

Exercice 6 Repérer une suite géométrique par programme

★★☆Environ 15 min

On dispose de trois listes de nombres :

A = [2, 6, 18, 54]
B = [1, 4, 9, 16]
C = [5, 5, 5, 5]

Écris une fonction est_geometrique(L) qui renvoie True si le quotient de deux termes consécutifs est constant, et False sinon (les listes ne contiennent aucun zéro).
Que renvoie-t-elle pour A, B et C ?
Quelle est la raison de la suite dont les termes sont ceux de A ?

Indice 1

Calcule le quotient L[1] / L[0], puis compare-le à tous les autres quotients L[i+1] / L[i].

Indice 2

Les calculs avec des nombres décimaux peuvent produire de petites erreurs d'arrondi ; ici, avec des entiers simples, la comparaison directe suffit, mais on peut aussi comparer les produits en croix.

Voir la correction pas à pas

On mémorise le premier quotient : q = L[1] / L[0].
On parcourt la liste : for i in range(1, len(L) - 1): if L[i+1] / L[i] != q: return False. Dès qu'un quotient diffère, on peut conclure.
Si la boucle va jusqu'au bout sans rien renvoyer, on termine par return True.
Pour A : $6/2 = 3$ , $18/6 = 3$ , $54/18 = 3$ ; la fonction renvoie True. Pour B : $4/1 = 4$ mais $9/4 = 2{,}25$ ; elle renvoie False. Pour C : tous les quotients valent 1 ; elle renvoie True.
La raison de la suite associée à A est le quotient commun : $54 / 18 = 3$ .

Une suite constante comme C est géométrique de raison 1 (et aussi arithmétique de raison 0). L'algorithme ne prouve pas qu'une suite infinie est géométrique : il vérifie seulement les termes de la liste, ce qui permet de formuler une conjecture à démontrer ensuite.

Exercice 7 Première somme qui dépasse mille

★★★Environ 20 min

Pour tout entier naturel $k$ , on pose $u_k = 3k + 2$ et, pour tout entier naturel $n$ , $S_n = u_0 + u_1 + \dots + u_n$ .

Écris un algorithme qui détermine le plus petit entier $n$ tel que $S_n > 1000$ .
Montre que $S_n = \dfrac{3n(n+1)}{2} + 2(n+1)$ .
Utilise cette formule pour vérifier la valeur de $n$ trouvée par l'algorithme.

Indice 1

Utilise deux variables qui évoluent ensemble : la somme S et l'indice n.

Indice 2

Pour la formule, la somme des entiers de 1 à $n$ vaut $\dfrac{n(n+1)}{2}$ , et il y a $n+1$ termes dans $S_n$ .

Voir la correction pas à pas

On initialise avec le premier terme : n = 0, S = 2 (c'est $u_0$ ).
On écrit la boucle : while S <= 1000: n = n + 1 puis S = S + 3 * n + 2. On ajoute le terme de rang $n$ après avoir augmenté $n$ .
Pour la formule, on sépare la somme : $S_n = 3(0 + 1 + \dots + n) + 2(n+1) = \dfrac{3n(n+1)}{2} + 2(n+1)$ .
On teste autour du seuil : pour $n = 24$ , $S_{24} = \dfrac{3 \times 24 \times 25}{2} + 2 \times 25 = 900 + 50 = 950$ , qui est inférieur à 1000.
Pour $n = 25$ , $S_{25} = \dfrac{3 \times 25 \times 26}{2} + 2 \times 26 = 975 + 52 = 1027$ , qui est supérieur à 1000. L'algorithme s'arrête donc sur $n = 25$ .

Le plus petit rang est $n = 25$ , avec $S_{25} = 1027$ . L'algorithme fonctionne même quand on ne connaît pas de formule, tandis que la formule sert à confirmer le résultat et à justifier qu'il est le plus petit : $S_{24} < 1000 < S_{25}$ .

Exercice 8 Rapprochement d'une valeur limite

★★★Environ 20 min

On considère la suite $(u_n)$ définie par $u_0 = 20$ et $u_{n+1} = 0{,}5\,u_n + 4$ .

Calcule $u_1$ , $u_2$ et $u_3$ à la main.
On pose $v_n = u_n - 8$ . Montre que $(v_n)$ est géométrique et donne son terme général.
Écris un algorithme qui renvoie le plus petit rang $n$ tel que $|u_n - 8| < 0{,}01$ , puis donne ce rang.

Indice 1

Pour la question 2, calcule $v_{n+1}$ en remplaçant $u_{n+1}$ par son expression et factorise.

Indice 2

Pour la question 3, la condition de la boucle while utilise abs(u - 8) >= 0.01.

Voir la correction pas à pas

On calcule : $u_1 = 0{,}5 \times 20 + 4 = 14$ , $u_2 = 0{,}5 \times 14 + 4 = 11$ , $u_3 = 0{,}5 \times 11 + 4 = 9{,}5$ . Les termes diminuent et semblent se rapprocher de 8.
On calcule $v_{n+1} = u_{n+1} - 8 = 0{,}5\,u_n + 4 - 8 = 0{,}5\,u_n - 4 = 0{,}5\,(u_n - 8) = 0{,}5\,v_n$ .
On en déduit que $(v_n)$ est géométrique de raison 0,5 et de premier terme $v_0 = 12$ , donc $v_n = 12 \times 0{,}5^n$ et $u_n = 8 + 12 \times 0{,}5^n$ .
On écrit l'algorithme : u = 20, n = 0, puis while abs(u - 8) >= 0.01: u = 0.5 * u + 4 et n = n + 1.
On cherche à la main : $|u_n - 8| = 12 / 2^n$ . Pour $n = 10$ , cela vaut $12/1024 \approx 0{,}0117$ , qui n'est pas inférieur à 0,01. Pour $n = 11$ , cela vaut $12/2048 \approx 0{,}0059$ , qui est inférieur à 0,01. Le rang cherché est 11.

Le rang est $n = 11$ . La condition équivalente $2^n > 1200$ montre pourquoi : $2^{10} = 1024$ est trop petit, $2^{11} = 2048$ suffit. Transformer une suite récurrente en suite géométrique auxiliaire permet de confirmer ce que l'algorithme découvre par essais.

Les questions qu'on se pose

Quand utiliser une boucle for et quand utiliser une boucle while pour une suite ?

Utilise for quand l'énoncé fixe le nombre de termes à calculer : « calculer $u_{10}$ », « donner les huit premiers termes ». Utilise while quand on cherche un seuil, c'est-à-dire un rang qu'on ne connaît pas à l'avance : « le plus petit $n$ tel que $u_n > 500$ ». Dans le second cas, on écrit comme condition le contraire de ce qu'on cherche, et on incrémente un compteur dans la boucle.

Pourquoi mon algorithme donne-t-il un rang trop grand ou trop petit d'une unité ?

C'est presque toujours un problème d'initialisation ou d'ordre des instructions. Vérifie trois choses : le compteur démarre-t-il au bon rang (0 ou 1) ? Mets-tu à jour le terme avant ou après avoir augmenté le compteur ? La comparaison est-elle stricte (>) ou large (>=) comme dans l'énoncé ? Le plus sûr est de tester l'algorithme sur un seuil dont tu connais la réponse, par exemple un seuil entre $u_2$ et $u_3$ calculés à la main.

Un algorithme peut-il remplacer une démonstration sur les suites ?

Non. Un algorithme calcule un nombre fini de termes : il permet de conjecturer (une suite semble géométrique, semble croissante, semble converger) ou de trouver un seuil, mais il ne prouve pas une propriété valable pour tous les rangs. À l'épreuve, on te demande souvent les deux : l'algorithme pour explorer, puis un raisonnement (calcul de $u_{n+1} - u_n$ , d'un quotient, ou récurrence) pour justifier.

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 : exercices corrigés de 1re spécialité

L'essentiel

Comment utiliser ces exercices

Les exercices

Exercice 1 Calculer un terme avec une boucle for

Exercice 2 Construire la liste des premiers termes

Exercice 3 Somme de termes avec une compréhension de liste

Exercice 4 Premier rang où des billes dépassent un seuil

Exercice 5 Capital placé et seuil

Exercice 6 Repérer une suite géométrique par programme

Exercice 7 Première somme qui dépasse mille

Exercice 8 Rapprochement d'une valeur limite

Les questions qu'on se pose

Sources

Primaire

Collège

Lycée

Supérieur