Algorithme de seuil : à partir de quel rang ? (Python, calculatrice, tableur)

Un algorithme de seuil calcule les termes d'une suite les uns après les autres, tant qu'une condition n'est pas atteinte, et renvoie le premier rang n pour lequel uₙ dépasse (ou passe sous) une valeur donnée. Il répond à la question la plus fréquente des sujets : « à partir de quelle année… ? ». Ce chapitre montre les quatre façons d'y répondre, la table de la calculatrice, le tableur, la boucle « tant que » en pseudo-code et en Python, et le calcul avec le logarithme, puis les pièges qui coûtent des points.

Le problème du seuil

Le pool tank du NAS de Sorbier Logistique contient 9 TiB d'archives, qui augmentent de 25 % par an, plus 4,3 TiB d'autres données stables. Le seuil de remplissage du pool est de 22,56 TiB (cours TrueNAS) : les archives ne doivent pas dépasser 22,56 − 4,3 = 18,26 TiB. À partir de quelle année les archives dépassent-elles 18,26 TiB ?

Les archives forment la suite géométrique uₙ = 9 × 1,25ⁿ, où n est le nombre d'années depuis 2026. On cherche le plus petit entier n tel que uₙ > 18,26. Comme la suite est croissante, une fois le seuil franchi, tous les termes suivants le dépassent aussi : on cherche le premier rang qui convient.

Avec la calculatrice : la table de la suite

Les calculatrices graphiques courantes ont un menu dédié aux suites, qui affiche la table des termes. Voici les étapes sur trois modèles répandus.

TI-83 Premium CE Edition Python

1. Appuie sur mode, descends à la ligne FONCTION PARAMÉTRIQUE POLAIRE SUITE (la cinquième), sélectionne SUITE avec les flèches et valide avec entrer. Quitte avec 2nde mode.
2. Appuie sur f(x). Sur la ligne TYPE, laisse SUITE(n). Règle nMin=0, puis saisis u(n)=1.25*u(n-1) (u s'obtient avec 2nde 7, n avec la touche X,T,θ,n) et u(nMin)=9.
3. Appuie sur 2nde fenêtre (déf table) : départ à 0, pas de 1.
4. Appuie sur 2nde graphe (table) et descends dans la colonne u(n) jusqu'au premier terme supérieur à 18,26.

Casio Graph 90+E

1. Dans le menu principal, ouvre le menu Récurrence (touche 8).
2. Appuie sur F3 (TYPE), puis F2 (an+1) pour une relation de récurrence.
3. Saisis la relation a(n+1)=1.25×an : la variable aₙ s'obtient avec F4 (n.an…) puis F2 (an). Valide avec EXE.
4. Appuie sur F5 (SET) : premier terme a0 = 9, valeur de départ 0, valeur de fin 10. Valide.
5. Appuie sur F6 (TABL) : la table des termes s'affiche.

Sur Graph 35+E II, le menu s'appelle RECUR et les touches sont les mêmes.

Casio Graph Math+

1. Ouvre le menu 7 Suites.
2. Dans Configuration > Type, choisis Un+1 (récurrence).
3. Saisis la relation et le premier terme ; les variables n et Un s'obtiennent avec la touche CATALOG, rubrique Suites. Valide avec Exécuter.
4. Ouvre l'onglet Table.

Sur les trois modèles, la table donne : u₃ ≈ 17,58 et u₄ ≈ 21,97. Le seuil est franchi au rang 4, soit en 2030.

Avec le tableur

Dans LibreOffice Calc ou Excel :

1. Écris les en-têtes, puis 0 en A2 et le premier terme 9 en B2.
2. En A3, =A2+1 ; en B3, la relation de récurrence =B2*1,25.
3. Sélectionne A3:B3 et recopie vers le bas avec la poignée de recopie : chaque ligne calcule le terme suivant à partir de celui du dessus.
4. Lis le premier rang dont la valeur dépasse 18,26.

Pour une suite explicite, écris directement en B2 =9*1,25^A2 et recopie vers le bas. Pour faire apparaître le seuil, ajoute en C2 =SI(B2>18,26;"dépassé";"") et recopie : le premier « dépassé » donne la réponse. Pour une somme cumulée, mets =B2 en C2, puis =C2+B3 en C3, et recopie.

Avec un algorithme : la boucle « tant que »

On ne sait pas à l'avance combien de termes il faudra calculer : c'est le cas typique de la boucle TantQue (while en Python). Le principe :

En pseudo-code, dans les conventions du cours d'algorithmique :

Algorithme SeuilArchives
// Rôle : premier rang n tel que uₙ = 9 × 1,25ⁿ dépasse 18,26
// Sortie : n, le rang cherché
Variables
    u : réel
    n : entier
Début
    u ← 9
    n ← 0
    TantQue u ≤ 18,26 Faire
        u ← 1,25 × u
        n ← n + 1
    FinTantQue
    Afficher(n)
Fin

En Python :

u = 9          # u0, en TiB
n = 0
while u <= 18.26:
    u = 1.25 * u
    n = n + 1
print(n, u)    # 4 21.97265625

La boucle fait 4 tours ; à la sortie, n vaut 4 et u vaut u₄ ≈ 21,97. Pour vérifier qu'un algorithme est juste, fais sa trace : la valeur des variables à chaque test.

Le même modèle pour toutes les suites. Seules l'initialisation, la condition et la mise à jour changent :

Pour les abonnés, la boucle renvoie 11, comme le calcul du chapitre 7. Pour le budget des licences, elle renvoie 5 : le total dépasse 100 000 € au cours de la cinquième année (101 467,67 €).

En fonction. Pour réutiliser l'algorithme, écris une fonction qui prend les données en paramètres :

def seuil_geometrique(u0, q, s):
    """Premier rang n tel que u0 * q**n > s (avec u0 > 0 et q > 1)."""
    u = u0
    n = 0
    while u <= s:
        u = u * q
        n = n + 1
    return n

print(seuil_geometrique(9, 1.25, 18.26))   # 4
print(seuil_geometrique(45, 1.12, 80))     # 6

Le second appel répond à la question du lien Lyon – Marseille : le trafic de pointe (45 Mbit/s, + 12 % par an) dépasse 80 Mbit/s au rang 6, en 2032.

Avec le calcul : l'inéquation et le logarithme

Pour une suite arithmétique, on résout une inéquation du premier degré (chapitre 2).

Pour une suite géométrique, l'inconnue est en exposant : 9 × 1,25ⁿ > 18,26 ⟺ 1,25ⁿ > 2,0289. On la fait descendre avec le logarithme népérien ln, la fonction de la touche ln de la calculatrice, qui transforme les puissances en produits : ln(qⁿ) = n × ln(q).

1,25ⁿ > 2,0289
n × ln(1,25) > ln(2,0289)      (ln est croissante, l'inégalité se conserve)
n > ln(2,0289) / ln(1,25)      (ln(1,25) > 0, l'inégalité se conserve)
n > 3,17

Le plus petit entier qui convient est n = 4.

Le logarithme appartient au module « Fonctions d'une variable réelle » de l'EF2 : le cours Fonctions et intégrales le présente en détail. À l'examen, la méthode par l'algorithme ou par la table suffit souvent ; la question précise la méthode attendue.

Les pièges qui coûtent des points

Exercices

u ← 500
n ← 0
TantQue ........ Faire
    u ← ........
    n ← ........
FinTantQue
Afficher(n)

u = 500
n = 0
while u >= 100:
    u = 0.85 * u
    n = n + 1
print(n)    # 10

u = 2
n = 0
while u < 50:
    u = 3 * u - 1
    n = n + 1
print(n, u)

v = 180
n = 1
while v > 900:
    v = v + 12
    n = n + 1
print(n)

v = 180
n = 0
while v < 900:
    v = v + 12
    n = n + 1
print(n)    # 60

def annees_budget(c0, q, budget):
    c = c0          # coût de l'année en cours
    total = 0
    annees = 0
    while total <= budget:
        total = total + c
        c = c * q
        annees = annees + 1
    return annees

print(annees_budget(18000, 1.06, 100000))   # 5