Chapitre 6 : les "tours de main"


Mise en Projet

Nous allons voir que le programmeur n'arrive pas complètement démuni devant chaque nouveau programme à créer. Il y a certaines situations qui se représentent souvent ou régulièrement dans les programmes à réaliser. Le fait de formaliser ces situations et d'en connaître les manières de les résoudre aide le programmeur dans sa tâche.

Dans ce chapitre, nous allons extraire 8 situations et donner le "truc", le "tour de main" qui permet de résoudre chacune d'entre elle facilement. C'est une façon de se constituer une "boîte à outils", outils qui seront bien utiles pour arriver à nos fins.

Pour chaque "tour de main", un robot sera à programmer afin de vérifier si ce "truc et astuce" est bien maîtrisé.

Objectifs

À l'issue de ce chapitre, l'élève sera capable :

  1. de connaître et comprendre les 8 tours de main abordés dans le chapitre et d'en donner les lignes directrices;
  2. de pouvoir choisir le bon tour de main à mettre en œuvre en fonction de la situation rencontrée;
  3. de pouvoir le mettre en œuvre correctement dans le programme réalisé.
Exposé

Les tours de main sont des façons de faire qui facilitent la vie des artisans. Que l'on soit sabotier ou programmeur, le tour de main est une petite routine qu'on peut appliquer sans trop se "casser la tête" quand c'est le bon moment. Avoir sa panoplie de tours de main à disposition, sa "boîte à outils", facilite la vie.

En programmation, il y a 8 tours de main. En voici la liste

  1. le tour de main du compteur;
  2. le tour de main de la somme;
  3. le tour de main du signal;
  4. le tour de main du plus petit et du plus grand;
  5. le tour de main du premier et du dernier;
  6. le tour de main du dernier qui devient avant-dernier.
  7. le tour de main de la boucle "pour".
  8. Bientôt...

Passons-les en revue et prenons-en le meilleur.

1. le tour de main du compteur

L'idée de compter quelque chose est que ce "processus" (lire un mot, extraire une donnée,...) va se représenter plusieurs fois. Une boucle telle qu'un RÉPÈTE peut être utilisée.

Plaçons les deux éléments de cette boucle et voyons ce qu'il nous faudrait avant, pendant et après la boucle...

Le tour de main du compteur

Réalise maintenant l'exercice illustrant ce tour de main : Le robot gardien de musée

2. le tour de main de la somme

On peut imaginer ici que le "processus" est de lire des nombres au clavier, de les extraires de "quelque part",... Une fois de plus, une boucle RÉPÈTE peut être utilisée.

Plaçons les deux éléments de cette boucle et voyons ce qu'il nous faudrait avant, pendant et après la boucle...

Le tour de main de la somme

Réalise maintenant l'exercice illustrant ce tour de main : Le robot employé de banque

3. le tour de main du signal

On peut imaginer ici que le "processus" est de nouveau la répétition d'un événement quelconque, répétition dans laquelle il faut détecter le passage d'une donnée bien précise. Une fois de plus, une boucle RÉPÈTE peut être utilisée.

Question signal, rien de plus approprié qu'un booléen : ce booléen sera à FAUX tant que l'événement précis ne s'est pas présenté, il sera mis à VRAI dès que l'événement précis se présente.

Plaçons les deux éléments de cette boucle et voyons ce qu'il nous faudrait avant, pendant et après la boucle...

Le tour de main du signal

Réalise maintenant l'exercice illustrant ce tour de main : Le robot vérificateur de bacs

4. le tour de main du plus petit et du plus grand

C'est peut-être le tour de main le plus délicat. Nous sommes de nouveau dans une répétition le lecture de nombres par exemple; en fin de lecture, le programme devra pouvoir afficher le plus petit et le plus grand nombre lus.

Le principe est d'avoir deux nombres de référence, un pour retenir le plus petit et l'autre le plus grand. Le problème est de savoir avec quelle valeur initialiser ces deux nombres : en tout cas pas avec 0 car on peut travailler uniquement avec des nombres négatifs (et 0 sera faussement le plus grand) ou dans les positifs (et 0 sera faussement le plus petit).

La méthode la plus sûre est de prendre le premier nombre lu comme référence, de cette façon, il n'y aura jamais d'erreur d'initialisation. Ce tour de main va donc être couplé avec celui du compteur.

Voici la manière dont les choses pourraient se passer :

Le tour de main du plus petit et plus grand

Réalise maintenant l'exercice illustrant ce tour de main : Le robot animateur de jeu

5. le tour de main du premier et du dernier

Dans une série d'événements (lecture de mots ou de nombres,...) on doit pouvoir signaler la position du premier et du dernier événement particulier (un mot ou un nombre particulier). Bien entendu, pour connaître les positions de l'événement en question, il faudra un compteur.

Voici, dans la lecture d'une série de mot, un moyen de repérer la position du premier et du dernier mot "Bonjour" dans la liste.

Le tour de main du premier et du dernier

Le "casier" Premier sert à la fois de "Mémoire" pour retenir la position du premier Bonjour, mais il sert aussi de signal. On l'initialise avec une valeur impossible, zéro, et la disparition de ce zéro signale que le premier Bonjour a été lu et qu'il ne faut désormais plus modifier le contenu de ce "casier".

Quant à Dernier, on actualise sa valeur dès qu'un nouveau Bonjour est rencontré, c'est peut-être le dernier...

En final, si le signal Premier contient toujours zéro, c'est que le mot Bonjour ne s'est jamais présenté, si Premier et Dernier sont égaux, c'est qu'il n'y a eu qu'un seul Bonjour.

Réalise maintenant l'exercice illustrant ce tour de main : Le robot scrutateur de trains

6. le tour de main du dernier qui devient avant-dernier

Ce dernier tour de main doit permettre de détecter, dans une série, deux événements précis qui se suivent exactement. Par exemple, dans une suite de mots, si le mot "Bonjour" est suivi exactement du mot "Au revoir".

Pour pouvoir réaliser cela, il faut garder en "mémoire" une copie du dernier mot lu, qui sera l'avant-dernier lorsque le mot suivant sera lu. La comparaison de ces deux mots doit permettre de savoir si l'objectif recherché est atteint.

Voyons comment il serait possible de réaliser cela.

Le tour de main du dernier qui devient avant-dernier

Quand on donne l'instruction "Mets "rien" dans le casier Dernier", c'est soit le la chaîne de caractères "rien" (qui peut convenir puisqu'elle est différente des deux mots recherchés), soit réellement la chaîne de caractère vide, vraiment rien du tout.

Réalise maintenant l'exercice illustrant ce tour de main : Le robot liseur de mots

7. le tour de main de la boucle "pour"

 7a. La boucle pour 

La boucle pour est une boucle répétitive dans laquelle l'incrémentation du compteur (le fait d'ajouter 1) est intégrée. La décrémentation est également possible. À chaque tour de boucle, cette incrémentation ou décrémentation se fera automatiquement sans qu'on ait à le signaler.

Pour que la boucle pour puisse fonctionner correctement, il faut lui fournir 4 éléments :

  1. le nom de la variable qui va compter les « tours de la boucle »;
  2. la valeur de départ que prendra cette variable au démarrage de la boucle;
  3. la valeur de fin de cette variable, valeur pour laquelle la boucle fera son dernier tour. Elle s'arrêtera après;
  4. l'incrémentation ou la décrémentation, à savoir le nombre d'unités que la boucle ajoutera ou retirera automatiquement à la variable à la fin de chaque tour de boucle.

Ce dernier élément peut paraître surprenant, mais il est possible d'ajouter ou de soustraire 2 ou 3 unités à chaque fois que la boucle fait un tour, tout dépend de l'utilisation qu'on en fait. En ce qui nous concerne, on se limitera à l'incrémentation d'une unité à chaque tour. Remarque : l'incrémentation se fait toujours après que les instructions contenues dans la boucle aient été exécutées.

Voici un exemple de comment se présente une boucle pour dont le nom de la variable est i (une vieille habitude de programmeur/euse), qui s'incrémente de 1 à chaque tour, qui démarre à la valeur 0 pour s'arrêter après la valeur 5, ces deux valeurs étant incluses (la boucle fera donc 6 tours avant de s'arrêter) :

  • Boucle pour
    • instruction 1
    • instruction 2
    • instruction 3
  • Fin pour

Peux-tu repérer dans cette boucle les 4 éléments dont nous avons parlé ? Que représente le signe Incrémentation ? Il s'agit bien sûr d'indiquer à la boucle qu'elle doit ajouter 1 à chaque tour.
Bien entendu, la variable i doit avoir été déclarée au préalable. Nous verrons cela en détail plus tard.

Attention : la boucle pour fonctionne de la même façon que la boucle tant que, c'est-à-dire que quand le programme arrive au fin pour il saute d'office à la ligne où se trouve le pour correspondant. C'est à ce moment que l'incrémentation ou la décrémentation a lieu.

 7b. Les variables tableau ou indicées 

Les variables tableau ou indicées sont des variables qui peuvent contenir plusieurs cases, chacune d'elle pouvant être repérée grâce à son indice, d'où leur nom. Voici un exemple de variable indicée s'appelant fruits, contenant 6 cases numérotées de 0 à 5 et chaque case contenant une chaîne de caractères.

fruits →manguebananefraisenoix de cocopommepapaye
indices →012345

L'accès à une case du tableau nécessitera d'office son indice entre crochets. Voici quelques exemples :

  • Affiche fruits[2] → affichera "fraise";
  • Affiche fruits[0] → affichera "mangue";
  • Écris "poire" dans fruits[4] → remplacera "pomme" par "poire".
 7c. Boucles pour et variables indicées 

Ces deux éléments vont souvent se retrouver ensemble, car la boucle pour est le moyen le plus facile pour balayer l'ensemble d'un tableau. Par exemple, je pourrais donner les instuctions suivantes :

  • Boucle pour
    • Affiche fruits[ i ]
    • Passe à la ligne suivante sur l'écran
  • Fin pour

À la première boucle, la variable i va prendre la valeur 0 et ce sera le contenu de la première case qui sera affiché. Puis la boucle va recommencer et va afficher le contenu de la case 1 (incrémentation)... et ainsi de suite jusqu'à afficher le contenu de la case 5. A la prochaine boucle, i sera égal à 6, ce qui est supérieur à la limite qu'on a donné à la boucle pour. L'ordinateur va donc sauter à la ligne qui suit le fin pour pour continuer la suite du programme. Voici l'affichage que l'on va obtenir :

  • mangue
  • banane
  • fraise
  • noix de coco
  • poire
  • papaye

Car "pomme" a été remplacé par "poire" !O)

Réalise maintenant l'exercice illustrant ce tour de main : Le robot calculateur de moyenne

  8. le tour de main des boucles "pour imbriquées" 

 8a. Les variables tableau ou indicées à deux dimensions 

Prenons le cas d'un agenda par exemple. Nous aurons deux types d'informations : les jours de la semaine et les périodes de la journée. Il s'agit donc bien d'une variable à deux dimensions dont les lignes et les colonnes peuvent chacune être identifiées par un indice.

agenda  01234567
0  Périodes ↓ Jours → Lundi  Mardi  Mercredi  Jeudi  Vendredi  Samedi  Dimanche 
1  Matin
2  MidiA...
3  Après-midi
4  SoirB...

Chaque "case" aura donc besoin de deux indices pour être identifiée, c'est le cas de l'activité "A" du mardi midi. L'accès à cette case s'écrira : agenda [ 2 , 2 ].

En ce qui concerne l'activité "B" du samedi soir, un problème se pose : dans quel ordre dois-je écrire les indices ? Dois-je écrire agenda[4,6] ou agenda[6,4] ?

Et bien, cela n'a aucune importance pour autant que cet ordre soit respecté dans l'absolue totalité du programme. Tout changement d'ordre provoquera des erreurs d'identification.

Afin d'éviter les erreurs, nous ferons un choix qui est celui de privilégier (de placer d'abord) dorénavant les lignes. Pour le samedi soir, nous écrirons donc agenda[4,6].

 8b. Les boucles pour imbriquées 

Chaque case nécessitant deux indices pour être identifiée, le balayage de tout le tableau nécessitera donc deux boucles pour imbriquées. Voici un exemple pour agenda.

Boucles pour imbriquées

Nous voyons que, par rapport au chapitre précédent, la syntaxe s'est un peu sophistiquée afin de pouvoir gérer plus finement les boucles dans les futurs exercices.

À partir de maintenant, pour que chaque boucle pour puisse fonctionner correctement, il faut lui fournir 6 éléments :

  1. l'instruction Pour qui signale le début de la boucle;
  2. le nom de la variable qui va compter les « tours de la boucle »;
  3. la valeur de départ de la boucle, qui pourra être une valeur ou une variable contenant cette valeur;
  4. la valeur de fin de la boucle, qui pourra être une valeur ou une variable contenant cette valeur;
  5. l'incrémentation Incrémentation ou la décrémentation Décrémentation, qui indiquera s'il faut ajouter ou retrancher des valeurs* à la valeur de départ pour obtenir la valeur de fin;
  6. et, pour terminer, l'instruction Fais qui termine la ligne d'informations concernant la boucle Pour.

* Il est possible d'ajouter ou retrancher une "certaine" valeur à chaque tour de boucle. Dans nos futurs exercices, ces valeurs se limiteront à +1 ou -1. Il faut juste savoir que c'est possible si, dans votre futur informatique, un cas spécial pouvait se présenter.

 8c. L'ordre des « pour » 

L'ordre dans lequel les pour vont se succéder aura une influence sur la façon dont la variable à deux dimensions sera balayée. Il est important de bien comprendre ce phénomène afin de pouvoir le maîtriser quand cela s'avèrera nécessaire. Il te sera demandé dans l'exercice d'expérimenter la chose.

Il ne te reste plus maintenat qu'à faire l'exercice de la "mosaïque" pour terminer cet ensemble des 8 tours de main.

Réalise maintenant l'exercice illustrant ce tour de main : Le robot faiseur de mosaïque

Retour