Algorithme de calcul des premiers termes d’une suite

1. Algorithme

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

$\left\{ \begin{matrix} u_{0}=3 \\ u_{n+1} = 0,5u_{n}+2\end{matrix}\right.$

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

2. Commentaires

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.

3. Résultats

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

4. Variante

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 :