💻Suites et seuils en Python

Une suite récurrente est définie par son premier terme et une relation qui donne le terme suivant à partir du précédent. Par exemple :

$u_0 = 3, \qquad u_{n+1} = 2\,u_n + 1.$

Pour calculer $u_n$, on part de $u_0$ et on applique $n$ fois la relation. En Python, on garde la valeur courante dans une variable u qu'on met à jour dans une boucle for répétée n fois :

def u(n):
    u = 3                 # u_0
    for _ in range(n):    # on applique la relation n fois
        u = 2 * u + 1     # u_{k+1} = 2*u_k + 1
    return u

Le _ est une variable « poubelle » : on ne s'en sert pas, on veut juste répéter n fois. Après la boucle, u contient $u_n$.

Pour programmer une suite récurrente :

1. Initialise la variable avec le premier terme (souvent $u_0$).
2. Répète exactement n fois avec for _ in range(n):.
3. À chaque tour, réaffecte la variable : u = (expression de u).
4. Renvoie la variable après la boucle.

Avec u(0) : la boucle for _ in range(0) ne tourne pas, on renvoie directement 3 (c'est $u_0$).

Avec u(2) : u = 3 → 2*3+1 = 7 → 2*7+1 = 15. Donc u(2) vaut 15.

range(n) produit n valeurs (de 0 à n-1), donc la boucle tourne n fois. Pour obtenir $u_n$ à partir de $u_0$, c'est exactement ce qu'il faut : n applications de la relation.

Question typique : « à partir de quel rang $n$ a-t-on $u_n > 1000$ ? ». On ne connaît pas le nombre d'étapes à l'avance : on répète tant que la condition n'est pas atteinte. C'est le rôle de la boucle while :

def seuil():
    u = 3
    n = 0
    while u <= 1000:       # tant qu'on n'a pas dépassé
        u = 2 * u + 1
        n = n + 1          # on compte les étapes
    return n               # premier rang où u > 1000

À la sortie de la boucle, la condition u <= 1000 est fausse, donc u > 1000 : n est bien le premier rang qui dépasse le seuil.

Pour une recherche de seuil :

1. Initialise la valeur u (premier terme) et le compteur n = 0.
2. Boucle while avec la condition « pas encore atteint » (ici u <= 1000).
3. Dans la boucle : mets u à jour puis incrémente n.
4. Renvoie n (ou u, selon la question).

Pour $u_0 = 3$, $u_{n+1} = 2u_n + 1$ : 3 → 7 → 15 → 31 → 63 → 127 → 255 → 511 → 1023. On a dépassé 1000 au 9ᵉ pas, donc seuil() renvoie 9 (c'est $u_9 = 1023$).

Attention à l'ordre dans la boucle : si tu mets u à jour puis comptes n, le compteur correspond au rang atteint. Vérifie toujours que la condition while finira par devenir fausse, sinon : boucle infinie !

Pour calculer $S = u_0 + u_1 + \dots + u_n$, on utilise un accumulateur : une variable S qui démarre à 0 et à laquelle on ajoute chaque terme au fur et à mesure.

def somme(n):
    u = 3
    S = u            # on ajoute déjà u_0
    for _ in range(n):
        u = 2 * u + 1
        S = S + u    # on ajoute le nouveau terme
    return S

Ici somme(n) calcule $u_0 + u_1 + \dots + u_n$ (soit n+1 termes).

Pour une somme de termes :

1. Crée un accumulateur (S = 0, ou S = u_0 si le premier terme est déjà connu).
2. À chaque tour de boucle, calcule le terme puis fais S = S + terme.
3. Renvoie S à la fin.

somme(0) : la boucle ne tourne pas, S = u_0 = 3.

somme(2) : S = 3, puis u=7, S=10, puis u=15, S=25. Donc somme(2) vaut 25 (c'est $3 + 7 + 15$).

Ne confonds pas la valeur du dernier terme (u) et la somme accumulée (S). Ce sont deux variables différentes qui évoluent en parallèle.

Le choix de la boucle dépend de ce que tu sais à l'avance :

• for : tu connais le nombre d'étapes (« calcule $u_{20}$ », « fais 100 itérations »). On écrit for _ in range(nb):.
• while : tu connais une condition d'arrêt mais pas le nombre d'étapes (« jusqu'à dépasser 1000 », « tant que l'écart est trop grand »).

Une suite croissante non majorée dépasse forcément n'importe quel seuil : la boucle while s'arrête. Une suite décroissante minorée par 0 peut servir à un seuil du type while u > 0.001:.

⭐ Pour les curieux — pourquoi ça marche ? Pourquoi une suite croissante non majorée finit-elle toujours par dépasser un seuil $M$ ? « Non majorée » veut dire exactement qu'aucun plafond ne tient : pour ce $M$, il existe forcément un rang $p$ avec $u_p > M$. Et comme la suite est croissante, une fois passé au-dessus elle y reste : tous les termes suivants dépassent aussi $M$. La boucle while s'arrête donc à coup sûr. Attention au piège inverse : une suite peut être croissante et bornée, comme $u_n = 2 - \dfrac{1}{2^n}$ qui grimpe ($1{,}5\,;\,1{,}75\,;\,1{,}875\dots$) mais n'atteint jamais $2$ — un while u < 2 tournerait alors à l'infini. C'est bien l'absence de majorant, pas la simple croissance, qui garantit l'arrêt.

Petit réflexe : « combien de fois ? » → for. « jusqu'à quand ? » → while. En cas de doute sur un while, demande-toi : « ma condition finira-t-elle par devenir fausse ? ».

« Calcule la somme des 50 premiers termes » → for. « Trouve le premier rang où $u_n < 0{,}01$ » → while u >= 0.01.

Une boucle while mal écrite peut tourner à l'infini. Dans la sandbox, ton code sera alors arrêté automatiquement : vérifie que la variable testée évolue bien à chaque tour.

L'erreur la plus fréquente est de se tromper du nombre de tours de boucle, ce qui décale tout d'un cran.

Rappel : for _ in range(n) exécute le bloc exactement n fois (les valeurs 0, 1, …, n-1). Pour calculer $u_n$ à partir de $u_0$, il faut donc appliquer la relation n fois — range(n) est correct, range(n+1) ferait un tour de trop.

def u(n):
    u = 3            # u_0
    for _ in range(n):   # n applications -> u_n
        u = 2 * u + 1
    return u

Pour une somme ou un seuil, c'est l'ordre des instructions dans la boucle (mise à jour de u puis du compteur, ou de l'accumulateur) qui doit être vérifié pas à pas sur un petit cas.

Pour éviter le décalage :

1. Écris à la main les premiers tours (u(0), u(1), u(2)).
2. Vérifie que u(0) renvoie bien $u_0$ (boucle vide).
3. Compte les applications : range(n) ⇒ n tours, pas un de plus.

Avec $u_0=3$, $u_{n+1}=2u_n+1$ : u(0) doit valoir 3 (boucle vide), u(1) vaut 2*3+1=7, u(2) vaut 2*7+1=15. Si u(0) te renvoie 7, c'est que tu fais un tour de trop (range(n+1)).

Le test à $0$ est ton meilleur ami : u(0) doit toujours renvoyer le premier terme sans entrer dans la boucle. Si ce n'est pas le cas, tu as un décalage.