TI-BASIC/Leçon 4 - Les boucles

En programmation, on a souvent besoin de refaire certaines fonctions ou partie de code, pour par exemple tester plusieurs variables plusieurs fois, ou au contraire tester différents cas possibles autour d'une seule variable. Heureusement pour nous, feignants absolus que nous sommes, des fonctions bien pratiques existent, que l'on appelle des boucles.
Ces fonctions permmettent d'exécuter une partie de code :
- soit TANT QUE telle condition est vérifiée,
- soit JUSQU'A que telle condition soit vérifiée,
- soit pendant une incrémentation/décrémentation d'une variable.

WHILE :

Le "Tant que" se traduit en anglais par "While" ([PRGM], [5]); voici la syntaxe de cette boucle :

:While [Condition]
:[Partie de code à exécuter tant que la condition est vérifiée]
:End

Quand la condition n'est plus vérifiée, on sort de la boucle après le "End". Une boucle se comporte comme un test : elle peut ne jamais être exécutée (si la condition n'est jamais vérifiée).
/!\ - Attention aux boucles infinies : si la condition est toujours vérifiée, le prgm ne sortira JAMAIS de la boucle et tournera donc en rond jusqu'au bug ou l'auto-destruction.
Exemple de boucle infinie :

:1->A
:While (A=1)
:Disp "HA !"
:End

Puisque A est toujours égal à 1 (on ne le modifie pas pendant la boucle), la calculette affichera sans s'arrêter :

:HA !
:HA !
:HA !
:HA !
:HA !
:HA !
:HA !
:HA !

C'est sans danger pour la TI, pas d'inquiétudes ! Pour stopper une boucle infinie (et de manière générale un prgm TI-Basic), il suffit d'appuyer sur la touche [ON], et le menu suivant s'affichera :

ERR:BREAK
1:Quit
2:Goto

"Quit" vous fera revenir à l'écran texte, et "Goto" vous emmenera dans le code-source, à la ligne à laquelle vous avez stoppé l'exécution du prgm.

Revenons à nos boucles ; et avant de voir les 2 restantes, attaquons un exercice assez difficile, qui vous fera rentrer dans la logique de la programmation et qui vous fera utiliser tout ce que l'on a vu depuis le début ! Allons-y gaiement : on veut un prgm qui demande un nombre ente 1 et 25 à l'utilisateur, et qui compte la différence entre ce nombre et je ne sais pas moi, disons 50.
Mais attention, pas de "50-nombre" !...
On va le faire ensemble, tout doucement, et par étape.
Commencons par le commencement, soit effacer l'écran, définir une variable A à 50 pour pouvoir tester, définir une variable R pour le résultat, dire à l'utilisateur ce qu'il doit faire, et demander un nombre N à l'utilisateur :

:ClrHome
:50->A
:0->R
:Disp "CHOISIR UN NBRE ","ENTRE 1 ET 25."
:Prompt N

Ensuite, on teste N pour savoir s'il est bien compris entre 1 et 25 :

:If ((N>1) and (N<25))
:Then

Maintenant on s'assure que N comprend uniquement un nombre entier en rentrant dans N la valeur entière du N entré par l'utilisateur. Pour prendre la valeur entière d'un nombre, on utilise la fonction on-ne-peut-plus simple int() :

:int(N)->N

On commence la boucle :

:While (N=/=A)

Alors pourquoi comparer N et A ? Je vous explique le fonctionnement de ce prgm : on va ajouter 1 à ("incrémenter") N jusqu'à arriver à A (auquel cas N sera égal à A et donc on sortira de la boucle) tout en comptant le nombre d'incrémentations effectuées. Ce total sera le résultat.
Donc, dans cette boucle on va tout d'abord ajouter 1 à N :

:N+1->N

Puis ajouter 1 à R :

:R+1->R

Et maintenant fermons notre belle boucle :

:End

Pour finir, on affiche le résultat :

:Disp "N EST DISTANT DE","50 DE",R

Sans oublier de fermer le test IF qui contient toute la boucle (on exécute la boucle que si N est bien compris entre 1 et 25) et l'affichage du résultat :

:End

Pfiouuuuu ! Difficile d'un coup hein ! Voici le prgm complet :

:ClrHome
:50->A
:0->R
:Disp "CHOISIR UN NBRE ","ENTRE 1 ET 25."
:Prompt N
:If ((N>1) and (N<25))
:Then
:int(N)->N
:While (N=/=A)
:N+1->N
:R+1->R
:End
:Disp "N EST DISTANT DE","50 DE",R
:End

Il faut bien comprendre que l'on imbrique des fonctions : la boucle While et son contenu est elle-même contenue dans le test IF. C'est un principe fondamental de la programmation séquentielle : on fonctionne avec des grandes boucles et des grands tests.

Quand je vous parlais de "logique de la programmation", je parlais de la capacité à transformer un problème en algorithme. On part d'un problème, d'une question, pour arriver à un schéma structuré mettant en scène des étapes (qui peuvent se répéter) afin de résoudre ce problème.
Ceci n'est pas inné, mais à force de programmer, votre cerveau sera entrainé à effectuer ce genre de conversion.
Bien sûr, pour ce prgm on aurait plus simplement faire la soustraction 50-N, mais l'essentiel ici était de vous montrer le raisonnement. Si pour vous c'est encore flou, reprenez l'exemple ligne par ligne, faites bien attention aux boucles/tests imbriqués, mais ne passez pas ce chapitre sans l'avoir compris. Quand ce programme sera pigé, vous aurez fait un grand pas dans votre avancée vers l'excellence !...

REPEAT :

[En cours d'écriture...]

Leçon précédente | Retour TI-Basic | Leçon suivante