In this French instructional video, the presenter introduces iterative structures in algorithm design, focusing on the while‑loop (structure « TantQue »). After recalling conditional structures, he explains why repeated execution of a code block is needed and how a loop automates this. The semantics of the while‑loop are described: a Boolean condition is evaluated before each iteration; if true, the block executes and the condition is re‑checked, otherwise the loop exits. The risk of an infinite loop is illustrated with a constant‑true condition. To guarantee termination, a loop counter variable (i) is introduced, initialized before the loop and updated each iteration. Two concrete algorithms are presented: (1) printing the word “Bonjour” a user‑specified number of times, showing step‑by‑step how the counter controls the loop; (2) computing n⁽ᵖ⁾ by repeated multiplication, detailing variable declarations (n, p, r, i), initialization of the result r to 1, and the update r ← r × n each iteration. The video mentions that other iterative structures (Pour, Répéter) exist but will be covered later. The overall message is that while‑loops provide a concise, scalable way to repeat operations without duplicating code.
Chapters
Bonjour à tous et bienvenue dans cette nouvelle leçon d'algorithmique. Aujourd'hui nous allons voir les structures itératives. Quand nous avons traité les structures conditionnelles, vous avez compris qu'un algorithme n'évolue pas toujours d'une manière linéaire du début à la fin. Parfois, on se trouve face à une dérivation qui nous mène à exécuter un traitement et non pas un autre. Le choix du traitement à exécuter dépend de la condition énoncée. Soit elle est vraie, soit elle est fausse. Or, parfois on se trouve face à un traitement que l'on doit répéter plusieurs fois, et au lieu de répéter manuellement le même bloc d'instructions, on va simplement mettre en place une structure itérative connue aussi sous le nom de boucle. Pour faire simple, imaginez que l'on veut calculer N à la puissance P, en considérant que N et P sont des entiers positifs. En algorithmique, nous avons vu que l'opérateur^ permet de faire un tel traitement, mais imaginez que vous vous servez d'un langage de programmation qui ne prend pas en charge cet opérateur-là. Dans ce cas, il faut que vous indiquiez au programme comment calculer cette puissance-là. Par exemple, 2 à la puissance 4 est égal à 2 fois 2 fois 2 fois 2. Il s'agit en fait de la multiplication de 2 par lui-même 3 fois de suite. Alors, on peut facilement reproduire un algorithme qui fait ce traitement. Mais imaginez que l'on veut maintenant calculer 2 à la puissance 25. Dans ce cas, nous aurons plus de multiplications à faire, il du coup le nombre de fois où l'on doit répéter la multiplication par 2 devient considérablement grand, ce qui signifie que le code qui en résultera devient tout aussi grand. Heureusement, les structures itératives viennent à la rescousse. En algorithmique et dans la plupart des langages de programmation, 3 structures itératives sont supportées: la structure TantQue, la structure Pour et la structure Répéter. En gros, ces 3 structures servent à faire la même chose, elles répéter le traitement autant de fois que nécessaire d'une manière automatique sans être obligé de réécrire le même code de nombreuses fois. Commençons par la structure TantQue. La structure TantQue s'exprime de cette manière. La condition placée après TantQue renvoie un résultat booléen, donc soit Vrai ou Faux, et elle peut représenter une expression faite à l'aide des opérateurs logiques OU, ET ou NON. Dans ce cas, l'exécution de la liste des instructions sera répétée tant que la condition est Vraie à la manière de l'organigramme suivant. En effet, quand on arrive à la condition, celle-ci est évaluée. Si elle est vraie, alors le bloc d'instructions est exécuté. Puis on retourne pour vérifier la condition à nouveau. Si elle est encore vraie, on réexécute le même bloc d'instructions et l'opération se répète de la même manière jusqu'à ce que l'on vérifie la condition et que celle-ci devienne fausse. Dans ce cas, on ignore le bloc d'instructions et on poursuit l'exécution du reste du code. On dit alors qu'on a quitté la boucle où on est sorti de la boucle, car sur l'organigramme ça se voit bien que la forme de la structure illustre bel et bien une boucle. On appelle chaque répétition de la boucle une itération. Par exemple, si la boucle est exécutée 4 fois, on dit qu'on a effectué 4 itérations. Supposons que l'on veut écrire le message Bonjour autant de fois que l'utilisateur le souhaite. Nous allons donc écrire l'algorithme suivant: Vous avez peut-être remarqué que je n'ai pas vraiment traité le nombre de répétitions exprimé par l'utilisateur. Tout ce que j'ai fait, c'est mettre l'expression booléenne Vrai après TantQue. Dans ce cas, la condition de la boucle est toujours vraie et celle-ci tournera indéfiniment. On aura donc une infinité de messages Bonjour sur l'écran. Dans le jargon de la programmation, on appelle ce phénomène une boucle infinie. Normalement, il faut bien que la condition finisse par devenir fausse, ce qui constitue la condition de sortie de la boucle afin de poursuivre le reste du traitement. Pour cela, nous allons introduire une autre variable de type entier que l'on appelle CompteurDeLaBoucle. Cette variable-là changera de valeur à chaque itération. Dans ce cas, la condition à mettre dans la structure TantQue est le fait que le compteur soit égal à une valeur donnée, et puisque celle-ci change de valeur à chaque fois, alors il finira bien par devenir égal à cette valeur-là. Bien entendu, si l'algorithme est bien écrit. Réécrivons maintenant l'algorithme en prenant en compte le compteur que l'on identifiera par i. Dans ce cas, après avoir récupéré la valeur de la variable n qui représente le nombre de Bonjour à écrire, Nous avons initialisé le compteur de la boucle à 0, puis nous avons amorcé la boucle. Pour mieux comprendre comment ça se passe, imaginons que l'utilisateur a saisi le nombre 3. Donc la variable n vaut 3 et elle conservera cette valeur jusqu'à la fin de l'algorithme. Avant d'entrer dans la boucle, la variable i vaut 0. La condition i est strictement inférieure à n est donc vraie, car 0 est strictement inférieur à 3. Alors on écrit Bonjour et on incrémente la variable i. C'est-à-dire que l'on ajoute 1 à la variable i et on stocke le résultat dans i elle-même. À ce stade, i vaut 1. On boucle au début de la structure et on vérifie la condition i strictement inférieur à N qui est encore vraie car 1 est strictement inférieur à 3. On affiche Bonjour encore une fois et on incrémente i dont la valeur devient 2. À ce stade, nous avons affiché 2 fois Bonjour. On recommence avec la condition qui est toujours vraie car 2 est strictement inférieur à 3. On affiche Bonjour une fois de plus et on incrémente i qui vaut maintenant 3. Jusqu'ici nous avons affiché 3 fois le message Bonjour, ce qui correspond au résultat escompté. Cependant, il faut recommencer pour vérifier la condition, qui cette fois devient fausse car 3 n'est pas strictement inférieur à 3. On quitte alors la boucle en ignorant le traitement qu'elle contient et on atteint la fin de l'algorithme avec 3 Bonjour affichés. Bien entendu, on peut initialiser la variable i à 1 et changer la condition pour qu'elle convienne avec la nouvelle valeur comme ceci. Nous allons maintenant écrire un algorithme qui permet de calculer la puissance de 2 nombres entiers positifs donnés par l'utilisateur. Tout d'abord, nous avons déclaré 4 entiers: n, p, r et i. n et p représentent respectivement la base et l'exposant. r représente le résultat de n à la puissance p. i le compteur de la boucle. Le traitement consiste à changer la valeur de r à chaque itération. C'est-à-dire, on prend son ancienne valeur, on la multiplie par la base puis on y stocke la nouvelle valeur et ainsi de suite jusqu'à la fin de la boucle. La valeur qui sera affectée à la variable R lors de la dernière itération constitue le résultat à afficher. Il ne faut pas oublier d'initialiser la variable R avec la valeur 1. Si on l'initialisait à 0, alors le résultat final serait nul aussi. On se contente de la structure TantQue pour le moment et on traitera les structures itératives restantes prochainement. Merci pour votre attention et à la vidéo prochaine.
