En abordant les exercices liés à la programmation dans les annales (Scilab ou Python depuis 2023), on constate fréquemment que les questions se concentrent sur la manipulation de suites. En sachant que la programmation a un poids de plus en plus important aux concours, il devient impératif de développer une maîtrise approfondie de la programmation de ces suites, qu’elles soient simples ou récurrentes linéaires d’ordre 2. Dans cet article, je vais te faire découvrir les divers cas de suites, en te montrant comment résoudre les problèmes qui peuvent surgir en cours de route.
Programmation d’une suite simple
Commençons avec une suite récurrente, ici une suite arithmético-géométrique (ce qui importe peu dans l’exercice, mais si tu sais coder celle-ci, tu pourras coder à la fois les suites arithmétiques et géométriques, ainsi que d’autres suites quelconques) :
\( \forall \ n \in \mathbb{N}, u_{n+1} = 2\;u_{n} + 1, u_{0}=0\)
Calcul d’un terme de la suite
Exécutons tout d’abord un programme qui calcule la valeur de \(u_n\) pour une valeur donnée de n entier donnée par l’utilisateur :
Ici, on initialise en affectant à u la valeur \(0\). Ensuite, il est important de savoir que la boucle ‘range(n)’ va de \(0\) à \(n-1\), et donc se répète \(n\) fois, puisque nous avons déjà \(u_0\) grâce à l’initialisation. Dans la quatrième ligne, on calcule le terme suivant en fonction du terme actuel, et u prend une nouvelle valeur.
Cependant, notre programme a une limite : il affiche uniquement le dernier terme. Or, si nous souhaitons étudier cette suite, par exemple graphiquement, il nous faut les termes précédents. Pour afficher tous les termes, nous pouvons utiliser une liste, qui nous permettra de stocker chaque terme au fur et à mesure.
Affichage d’une liste de termes de la suite
Nous devrons ici utiliser la commande ‘append’, qui permet d’ajouter un élément à la fin d’une liste existante. La syntaxe générale est la suivante :
- ‘liste’ : c’est la liste à laquelle tu souhaites ajouter un élément.
- ‘élément’ : c’est la valeur que tu veux ajouter à la fin de la liste. En prenant la même suite qu’avant, voici alors comment légèrement modifier le programme pour résoudre ce problème :
On crée une liste vide L pour stocker les termes de la suite. Puis, on ajoute \(u_0\) à la liste (on aurait directement pu mettre L = [0] pour n’avoir qu’une ligne de code). En intégrant ‘append’ dans la boucle ‘range’, on ajoute chaque nouveau terme calculé à la liste. La commande ‘return L’ permet de renvoyer la liste complète des termes de la suite.
Manipuler les listes en compréhension pour programmer des suites explicites
D’ailleurs, avec une suite explicite, c’est encore plus simple. Il suffit d’utiliser une liste en compréhension. Prenons la suite géométrique \(v_n\) de paramètre 2. Pour la programmer, il suffit de procéder comme suit :
- ‘range(n+1)’ crée une séquence d’entiers de 0 à n.
- La liste en compréhension [2 ** i for i in range(n)] parcourt chaque valeur de ‘i’ dans la séquence ‘range(n)’ et calcule le résultat de 2 à la puissance i, créant ainsi une liste contenant les termes d’une suite géométrique.
- ‘return L’ : enfin, la fonction renvoie la liste générée.
Cas où le paramètre n se trouve dans la suite
Lorsque le paramètre n se trouve dans la suite, il faut faire très attention aux valeurs que va prendre la séquence ‘range’. Prenons la suite suivante : \( \forall \ n \in \mathbb{N}, w_{n+1} = 2\;w_{n} + n, w_{0}=1\)
Programmons :
Ici, on prend les valeurs de \(0\) à \(n-1\), ce qui équivaut à écrire range(0,n). Pour s’en convaincre, il est judicieux de « tester » les premiers termes et les derniers termes de la boucle pour voir si cela est conforme. Par exemple, puisqu’on connaît \(w_0\) , on doit calculer \(w_1=2w_0 + 0\), et donc le premier terme de la boucle, c’est-à-dire la valeur que prend \(k\), est \(0\).
Suite récurrente linéaire d’ordre 2
Après avoir exploré la programmation des suites de base, explorons comment créer un programme en Python pour générer une suite récurrente linéaire d’ordre 2. Pas de panique, je serai là pour t’accompagner à chaque étape. Avant de plonger dans l’algorithme, prenons quelques instants pour nous rappeler les bases.
Dans une suite récurrente linéaire d’ordre 2, chaque terme est obtenu en combinant les deux termes précédents. Prenons alors la suite récurrente linéaire d’ordre 2 suivante :
\( \forall \ n \in \mathbb{N}, a_{n+2} = 2\;a_{n+1} + 3\;a_{n}, a_{0}=0, a_{1}=1\)
N.B. : Cette suite peut aussi s’écrire sous la forme \(a_{n} = 2\;a_{n-1} + 3\;a_{n-2}\) que nous utiliserons pour rendre plus simple la compréhension.
Passons alors au code ! Si tu veux t’entraîner, essaie de rédiger le programme seul(e) avant de voir la réponse.
- an_moins_1 : cette variable stocke le terme précédent (celui qui a été calculé lors de la dernière itération). C’est le \(a_{n+1}\) dans la formule de base.
- an_moins_2 : ici, nous stockons le terme encore plus ancien, celui qui a été calculé avant an_moins_1. C’est le \(a_n\) dans la formule.
À chaque itération de la boucle, nous calculons le terme actuel en utilisant la formule, puis mettons à jour les valeurs de an_moins_1 et an_moins_2 pour les utiliser dans le prochain calcul.
N.B. : La boucle for commence à partir du troisième terme (indices 2 et 3), car nous avons déjà fourni les deux premiers termes. Néanmoins, le paramètre importe peu, donc on aurait aussi pu écrire range(n-2) (de \(0\) à \(n-3\), donc \(n-2\) fois), car ce qui compte ici, c’est le nombre d’itérations. Tu relèveras également que le paramètre \(n\) entré par l’utilisateur doit être supérieur ou égal à 2, car on souhaite entrer dans la boucle. Sinon, si on veut pouvoir mettre 0 ou 1, il faut intégrer des boucles if dans le programme en question.
Il y a aussi une autre méthode, qui utilise moins de variables, mais qui conserve la même logique. Dans cette version allégée, nous réduisons le stockage en utilisant simplement ancien_a. C’est celle que notre professeur a montrée, mais je pense que le programme précédent, plus simple, permet de saisir la logique de celui-ci.
- Nous stockons la valeur actuelle de ‘an_moins_1’ dans ‘ancien_a’. Cela nous permet de sauvegarder la valeur actuelle de ‘an_moins_1’, car elle va être mise à jour dans la prochaine ligne.
- Ensuite, ‘an_moins_1’ est mis à jour et prend la dernière valeur de la suite.
- Enfin, ‘an_moins_2’ est mis à jour en prenant la valeur précédente de ‘an_moins_1’ (qui a été sauvegardée dans ‘ancien_u’). Cela prépare les valeurs pour la prochaine itération.
Représentation graphique d’une suite
Maintenant que nous avons exploré la programmation de suites en Python, il est temps de passer à une étape visuelle : la représentation graphique des suites. Cela peut nous aider à visualiser le comportement de la suite.
Reprenons alors la toute première suite (exprimée sous forme de liste) que nous avons sous la forme suite_u(n). Voici alors un programme possible pour afficher graphiquement les 100 premiers termes de la suite.
- import matplotlib.pyplot as plt importe le module matplotlib.pyplot (abréviation : plt) qu’on utilise pour représenter graphiquement des fonctions sur Python.
La ligne 4 crée le graphique en utilisant la fonction ‘plot()’ de ‘matplotlib.pyplot’. Elle prend deux arguments principaux :
- ‘range(n + 1)’ : les valeurs de l’axe horizontal (l’indice des termes), qui vont de 0 à 100+1-1 (donc 100) dans cet exemple.
- ‘termes’ : les valeurs de l’axe vertical (les termes de la suite) qui ont été générées précédemment. Le ‘+’ spécifie le style de marquage pour chaque point sur le graphique.
Il n’est pas requis de mettre de titres et étiquettes, mais je pense que si tu as le temps, c’est un petit plus sur ta copie. Normalement, une fenêtre s’ouvrira sur ton ordi, avec une jolie suite.
Conclusion et petit conseil méthodologique
J’espère que cet article te permettra de t’améliorer dans la programmation de suites sur Python. Maintenant, il faut passer à l’action. Mon professeur de première année (qui se reconnaîtra peut-être) disait que pour Python, il s’agissait de « mettre les mains dans le cambouis », et il a raison.
Plutôt que de suivre les cours de Python sur papier et d’apprendre par cœur des algorithmes, je te conseille vivement de prendre un ordinateur et d’essayer de programmer ces suites toi-même et de voir si tu aboutis au même résultat. Cela te permettra de progresser beaucoup plus rapidement et de grappiller des points cruciaux pendant les épreuves de mathématiques. Tu peux d’ailleurs ouvrir la console Python de Major-Prépa prévue à cet effet.
