Calculer les termes d'une suite et un algorithme de seuil

Calculer les termes d'une suite par récurrence

Une suite définie par récurrence ($u_0$ donné, $u_{n+1}=f(u_n)$) se calcule naturellement avec une boucle for, en mettant à jour une variable à chaque tour.

Exemple : suite arithmétique $u_0=3$, $u_{n+1}=u_n+5$.

`python
u = 3
for i in range(10):
u = u + 5

print(u)
`

Ce programme calcule $u_{10}$ : à chaque tour de boucle, u est remplacé par sa valeur précédente plus $5$.

Stocker les termes dans une liste

Pour conserver tous les termes calculés (et pas seulement le dernier), on les ajoute à une liste avec .append() à chaque tour :

`python
u = 3
termes = [u]
for i in range(10):
u = u + 5
termes.append(u)

print(termes)
`

termes contient alors $u_0, u_1, \ldots, u_{10}$, soit $11$ valeurs.

Algorithme de seuil

Un algorithme de seuil détermine le plus petit rang $n$ à partir duquel une suite (croissante) dépasse une valeur donnée. On utilise une boucle while, qui s'arrête dès que la condition est vérifiée :

`python
u = 3
n = 0
while u <= 100:
u = u + 5
n = n + 1

print("Rang :", n, " Valeur :", u)
`

Point clé : la boucle while condition: répète les instructions tant que la condition est vraie, et s'arrête dès qu'elle devient fausse. Il faut que la condition finisse par devenir fausse, sinon la boucle ne s'arrête jamais !

Exemples

✅ Exemple simple — Calculer un terme d'une suite géométrique

`python
v = 2
for i in range(5):
v = v * 3

print(v)
`

Ce programme calcule $v_5$ pour la suite géométrique $v_0=2$, $v_{n+1}=3v_n$ : il affiche 486.

📘 Exemple intermédiaire — Stocker les 6 premiers termes

`python
v = 2
termes = [v]
for i in range(6):
v = v * 3
termes.append(v)

print(termes)
`

Ce programme affiche la liste [2, 6, 18, 54, 162, 486, 1458], soit $v_0$ à $v_6$.

🔴 Exemple avancé — Algorithme de seuil pour une suite géométrique

`python
v = 2
n = 0
while v < 1000:
v = v * 3
n = n + 1

print("Rang :", n, " Valeur :", v)
`

Ce programme cherche le plus petit rang $n$ pour lequel $v_n \geqslant 1000$, en multipliant v par $3$ à chaque tour tant que $v<1000$.

À retenir

- Une boucle for qui met à jour une variable permet de calculer le terme d'une suite définie par récurrence.
- .append() dans la boucle permet de conserver tous les termes calculés dans une liste.
- Une boucle while condition: répète tant que la condition est vraie : c'est l'outil adapté pour un algorithme de seuil, où l'on ne connaît pas à l'avance le nombre de répétitions nécessaires.