Algorithme de calcul des premiers termes d’une suite

Voici un algorithme répondant à la question pour la suite $ \left(u_{n}\right) $ définie par :

Remarque : Cet algorithme n'est pas le seul possible.

Lignes 1 et 2 : On définit 3 variables :

• $ k $ contiendra la valeur saisie par l'utilisateur qui déterminera l'arrêt de la boucle. $ k $ ne sera pas modifié lors du traitement mais gardera une valeur constante
• $ i $ contiendra le rang (indice) du terme que l'on calcule à partir du rang 1. $ i $ variera de $ 1 $ à $ k $
• $ u $ contiendra les valeurs de $ u_{i} $. Notez que l'on définit une seule variable pour l'ensemble des termes de la suites. Au départ cette variable sera initialisée à $ u_{0} $. Puis on calculera $ u_{1} $ qui viendra «écraser » $ u_{0} $. Puis $ u_{2} $ viendra écraser $ u_{1} $ et ainsi de suite...

Ligne 3 : La valeur saisie par l'utilisateur qui déterminera l'arrêt de l'algorithme est stockée dans la variable $ k $

Ligne 4 : On initialise $ u $ en lui donnant la valeur de $ u_{0} $ (ici $ u_{0}=3 $).

Ligne 5 : On affiche la valeur de $ u $ (qui contient actuellement $ 3 $). Cette ligne est nécessaire pour afficher la valeur de $ u_{0} $ car la boucle qui suit n'affichera que les valeurs de $ u_{1} $ à $ u_{n} $.

Ligne 6 : On crée une boucle qui fera varier l'indice $ i $ de $ 1 $ à $ k $. Puisqu'ici on connait le nombre d'itérations $ k $, une boucle Pour a été préférée à une boucle Tant que.

Ligne 7 : On modifie la valeur de $ u $ : La nouvelle valeur de $ u $ sera égale à l'ancienne valeur de $ u $ fois $ 0{,}5 $ plus $ 2 $. Cela traduit bien la relation de récurrence $ u_{n+1}= 0{,}5u_{n}+2 $.

Ligne 8 : On affiche le terme que l'on vient de calculer (à savoir $ u_{i} $).

Ligne 9 : On « ferme » la boucle ; on retourne à la ligne 6 ; si $ i $ valait $ k $, la boucle se terminera alors et on passera à la ligne 10.

Ligne 10 : L'algorithme est terminé !

Remarque :Il faut toujours être très attentif au nombre de passages dans la boucle et au nombre d'affichages. Pour vérifier son algorithme, on peut :

• faire « tourner » l'algorithme (c'est-à-dire créer un tableau contenant les valeurs des variables étape par étape) - voir 3. ci-dessous.
• compter le nombre d'affichages :
  
  Ici on souhaite afficher les valeurs de $ u_{0} $ à $ u_{k} $, c'est-à-dire $ k+1 $ valeurs.
  
  La ligne 5. effectue un premier affichage (de $ u_{0} $).
  
  La boucle affichera, quant à elle, $ k $ valeurs puisque $ i $ varie de $ 1 $ à $ k $
  
  En tout on a donc bien effectué $ k+1 $ affichages.

Le tableau ci-dessous récapitule les valeurs prises par les variables pour $ k=4 $

Cette fois, on ne souhaite pas afficher toutes les valeurs de $ u_{0} $ à $ u_{k} $ mais uniquement la valeur $ u_{k} $.

Les modifications à apporter à l'algorithme sont les suivantes :

• On supprime la ligne 5 puisque l'on ne souhaite plus afficher $ u_{0} $
• On supprime la ligne 8 puisque l'on ne souhaite plus afficher tous les termes de $ u_{1} $ à $ u_{n} $
• On ajoute une ligne « Afficher $ u $ » après la boucle pour afficher la dernière valeur calculée dans la boucle (et qui correspond à $ u_{k} $)

On obtient l'algorithme ci-dessous :