Algorithmique et langages

Transcription

1 BTS Informatique de gestion 2 e année Option administrateur de réseaux locaux d entreprise Jean-Yves Février Algorithmique et langages Autocorrection Directrice de publication : Valérie Brard-Trigo Les cours du Cned sont strictement réservés à l usage privé de leurs destinataires et ne sont pas destinés à une utilisation collective. Les personnes qui s en serviraient pour d autres usages, qui en feraient une reproduction intégrale ou partielle, une traduction sans le consentement du Cned, s exposeraient à des poursuites judiciaires et aux sanctions pénales prévues par le Code de la propriété intellectuelle. Les reproductions par reprographie de livres et de périodiques protégés contenues dans cet ouvrage sont effectuées par le Cned avec l autorisation du Centre français d exploitation du droit de copie (20, rue des Grands Augustins, Paris).

2 Sommaire Séquence 1 : Variables et instructrions 3 Séquence 2 : Procédures et fonctions 15 Séquence 3 : Tableaux, structures et types 19 Travaux dirigés 1 33 Travaux dirigés 2 46 Travaux dirigés 3 65

3 Séquence 1 Variables et instructions Exercice 1 La solution se trouve dans la suite du cours. Exercice 2 Ce commentaire explique comment fonctionnent l accès à un élément d un tableau, l affectation et la boucle pour. Il n a donc aucun intérêt dans un programme car si vous savez ce qu est une affectation et une boucle pour, il ne vous apprend rien. De plus, il est écrit sans soin, car la iable LongueurTableau du code devient LongueurTab dans le commentaire. C est source de confusion. Exercice 3 Ces termes sont normalement très simples intuitivement, mais pour les déir ce n est pas si facile! Voici ce que je vous propose : le type est un concept abstrait déissant quelque chose ; en programmation, le type indique la nature d une valeur : entier, entier long, réel, caractère ; la iable est un espace mémoire contenant une valeur. La iable sera toujours d un type donné. C est important car : la taille de l espace mémoire utilisé iera avec le type : il faut plus de place pour stocker le nombre ,489 que la lettre F ; les valeurs étant stockées sous la forme de bits (des 0 et des 1), il faut connaître leur nature pour les coder et les décoder. Par exemple, la date 07/12/1970 ne sera pas codée sous la forme de 0 et de 1 de la même façon que la chaîne "Mon teckel dort." (Nous reverrons cela dans la suite du cours.) La déclaration d une iable consiste à lui réserver son espace mémoire. Il faut préciser le type de la iable pour savoir quelle taille de mémoire lui accorder et déterminer la technique de codage et décodage en bits à employer. En, il faut toujours donner un nom à la iable déclarée. Pourquoi? Car si l on stocke une donnée dans la mémoire, c est pour s en servir. Et, pour s en servir, il faut pouvoir l identifier par rapport aux autres iables. Le plus simple est de lui donner un nom. Pour le compilateur, n importe quelle suite arbitraire de caractères constitue un nom valide. Il est cependant évident que le développeur doit utiliser un nom ayant un sens par rapport au contenu de la iable pour que le code soit intelligible. Par exemple, pour stocker le prix TTC d un produit, le nom PrixTTC sera évidemment préféré à Prix, P ou, pire encore, PrixHT. Exercice 4 Voir la suite du cours. 3

4 Séquence 1 Exercice 5 Le principe sera le suivant : 1. L utilisateur doit saisir le nombre à tester. 2. Selon la valeur du calcul, on affiche pair ou impair. Il faut évidemment déclarer la iable (ce sera un entier). Cela donne : Algo parité1 Nombre : entier saisir "Entrez un nombre : ", Nombre si Nombre mod 2 = 0 Afficher "Le nombre est pair." sinon Afficher "Le nombre est impair." si Si vous avez inversé le test (Nombre mod 2 = 1 ou Nombre mod 2 <> 0), les deux instructions du et du sinon sont permutées : Algo parité2 Nombre : entier saisir "Entrez un nombre : ", Nombre si Nombre mod 2 <> 0 Afficher "Le nombre est impair." sinon Afficher "Le nombre est pair." si Assurez-vous que vous êtes d accord avec cette proposition : «ces deux algorithmes donnent exactement le même résultat». Exercice 6 Voir la suite du cours. 4

5 Variables et instructions Exercice 7 1 er bloc 01 afficher "avant boucle" 02 tant que (2 = 3) faire 03 afficher "dans boucle" 04 x := x/0 05 tant que 06 afficher "après boucle" Ce bloc possède trois instructions : 1. Afficher en ligne La boucle tant que en lignes 2 à 5. Cette instruction en contient deux : afficher (ligne 3) puis une affectation (ligne 4). 3. Afficher en ligne 6. Comme nous l avons déjà vu (paragraphe 2), on va exécuter la première instruction, puis la deuxième et en la troisième : 1 re instruction : l application affiche avant boucle ; 2 e instruction : on exécute le tant que (évaluation du booléen, s il est vrai on exécute les instructions). Eh bien, le booléen vaut faux (en effet 2 n est pas égal à 3). On n exécute donc pas les instructions contenues dans le tant que et on passe à l instruction suivante (sous entendu «suivant le tant que», donc ligne 6) ; 3 e instruction : l application affiche après boucle. L exécution de ce bloc produira donc l affichage suivant : avant boucle après boucle Notez bien que 2 = 3 est tout à fait juste syntaxiquement (comme x = y). C est une constante booléenne qui vaut faux. De même, 1+0 est une constante entière valant 1. La leçon à retenir? Si le booléen est toujours faux, les instructions contenues dans la boucle ne sont pas exécutées ; cette dernière ne sert donc à rien. Le bloc précédent pouvait donc s écrire : afficher "avant boucle" afficher "après boucle" Le piège résidait dans le booléen mais aussi dans la ligne 4 : la division par zéro provoque une erreur si l instruction est exécutée. Mais ce n est pas le cas ici, donc pas d erreur. 2 e bloc afficher "avant boucle" i := 1 tant que (i > 0) faire afficher "dans boucle" i := i+1 tant que afficher "après boucle" 5

6 Séquence 1 Ici, quatre instructions (dans l ordre afficher, une affectation, la boucle contenant un afficher et une affectation puis encore un afficher). Les deux premières s exécutent sans problème. Quand on arrive sur la boucle, i vaut 1. Exécution de la boucle : 1. On évalue le booléen : i > 0 correspond à 1 > 0, ce qui est vrai. Les instructions de la boucle sont exécutées (on affiche dans boucle puis on incrémente i qui vaut 2) puis on recommence l exécution de la boucle. 2. On évalue le booléen : i > 0 correspond à 2 > 0, ce qui est vrai. Les instructions de la boucle sont exécutées (on affiche dans boucle puis on incrémente i qui vaut 3) puis on recommence l exécution de la boucle. 3. On évalue le booléen : i > 0 correspond à 3 > 0, ce qui est vrai. Les instructions de la boucle sont exécutées (on affiche dans boucle puis on incrémente i qui vaut 4) puis on recommence l exécution de la boucle. 4. Inutile de continuer : comme on ajoute 1 à i, il va croître indéiment (valant 5, 6 ) et sera évidemment toujours supérieur à 0. Le booléen ne sera jamais faux donc la boucle ne s arrêtera jamais. La dernière instruction du bloc ne sera jamais exécutée. Voici l affichage que nous aurons : avant boucle dans boucle dans boucle dans boucle dans boucle La leçon à retenir? Si le booléen est toujours vrai, la boucle est exécutée indéiment. Pour éviter cela, il faut vérifier que les instructions incluses dans la boucle rendent le booléen faux à un moment donné. Simplifions le bloc précédent. Il pouvait s écrire : afficher "avant boucle" tant que vrai faire afficher "dans boucle" tant que Je n essaye plus d afficher après boucle puisque je sais maintenant que je n y arriverai jamais. Je n utilise plus i puisque en fait il ne sert à rien. 3 e bloc afficher "avant boucle" i := 1 tant que (i > 0) faire afficher "dans boucle" i := i-1 tant que afficher "après boucle" C est le même bloc que précédemment sauf que l on décrémente i dans la boucle. 6

7 Variables et instructions On affiche avant boucle. Quand on arrive sur la boucle, i vaut 1. Exécution de la boucle : 1. On évalue le booléen : i > 0 correspond à 1 > 0, ce qui est vrai. Les instructions de la boucle sont exécutées (on affiche dans boucle puis on décrémente i qui vaut 0) puis on recommence l exécution de la boucle. 2. On évalue le booléen : i > 0 correspond à 0 > 0, ce qui est fauxå. L exécution de la boucle s arrête. On arrive à la dernière instruction du bloc qui affiche après boucle. Voici l affichage que nous aurons : avant boucle dans boucle après boucle On voit bien que les instructions dans la boucle vont rendre le booléen faux un jour ou l autre : partant d un nombre positif, on le décrémente ; on arrivera donc forcément à 0. Le bloc pouvait s écrire : afficher "avant boucle" afficher "dans boucle" afficher "après boucle" 4 e bloc afficher "avant boucle" i := 5 j := -1 tant que (i > 0) faire afficher "dans boucle" j := j+1 tant que afficher "après boucle" Nous avons 5 instructions, dans l ordre afficher, deux affectations, une boucle puis afficher. Lorsque l on arrive sur la boucle, i vaut 5 et j vaut 1. Maintenant que nous avons un peu de pratique, essayons de raisonner sans exécuter à la main le programme. Dans la boucle, on réalise un affichage et on modifie la valeur de j. Celle de i reste inchangée. Ainsi, le booléen i > 0 ne change pas. Ce sera toujours 5 > 0 (puisque i vaut 5). Or cela est vrai. La boucle ne s arrête donc pas. å Attention au piège bête (classique, mais bête) : x >= x est vrai mais x > x est faux : un nombre n est pas plus grand que lui-même. 7

8 Séquence 1 Voici l affichage que nous aurons : avant boucle dans boucle dans boucle dans boucle La leçon à retenir? Pour que la boucle s arrête un jour, il faut, nous l avons vu, que les instructions contenues dans la boucle rendent le booléen faux. Et, pour que cela arrive, il faut que les iables utilisées dans le booléen soient modifiées par les instructions. Ici, comme le booléen est fonction de i et que i n est pas modifié dans la boucle, on sait que la boucle ne s exécutera jamais (booléen initialement faux) ou ne s arrêtera pas (booléen initialement vrai). Une dernière remarque : on modifie la iable j mais on ne s en sert jamais. On peut donc l enlever car elle ne sert à rien. Le bloc précédent pouvait donc s écrire : afficher "avant boucle" i := 5 tant que (i > 0) faire afficher "dans boucle" tant que Voire : afficher "avant boucle" tant que (5 > 0) faire afficher "dans boucle" tant que Soit : afficher "avant boucle" tant que vrai faire afficher "dans boucle" tant que Exercice 8 1 er bloc répéter saisir "Entrez l âge : ", âge jusqu à (âge > 0) et (âge < 120) 8

9 Variables et instructions Reprenons les étapes du cours : 1. On exécute les instructions de la boucle : on affiche Entrez l âge : et on attend la saisie de l utilisateur que l on stocke dans la iable âge. 2. On évalue le booléen. Celui-ci vaudra vrai si l âge est compris entre 0 et 120 exclus et faux sinon. Ainsi, si âge vaut moins de 1 ou plus que 119 (c est une iable entière), on recommence la boucle. Que fait cette boucle? Elle assure que la valeur saisie est correcte puisque tant que l utilisateur rentre une valeur fantaisiste, on lui redemande. 2 e bloc répéter x := x/0 jusqu à x = x On exécute les instructions dans la boucle Le programme plante car on fait une division par zéro. Tout cela pour vous rappeler que l on exécute les instructions de la boucle avant de calculer la valeur du booléen (ici, x = x) et non après comme avec un tant que. Revoyez la division par zéro du premier bloc de l exercice 7. Exercice 9 1 er bloc pour i de 1 à 10 pas 5 afficher i pour On reprend la démarche du cours (avec le cas entier1 < entier2) : 1. i est initialisé à i étant inférieur ou égal à 10 (1 < 10), on exécute les instructions contenues dans la boucle. On affiche donc i, soit On incrémente i de 5. L indice i vaut i étant inférieur ou égal à 10 (6 < 10), on exécute les instructions contenues dans la boucle. On affiche donc i, soit On incrémente i de 5. L indice i vaut i est supérieur à 10 (11 > 10). On s arrête. Ce n est pas un algorithme très utile! Son objet est simplement de vous rappeler le fonctionnement du pour. 2 e bloc pour i de 10 à 1 pas 1 pour j de 10 à 1 pas -1 afficher i, "x", j, "=", i*j pour pour 9

10 Séquence 1 On reprend la démarche du cours (avec le cas entier1 > entier2) : 1. i est initialisé à i étant supérieur ou égal à 1 (10 > 1), on exécute l instruction contenue dans la boucle soit une autre boucle (avec le cas entier 1 > entier 2 ) : a. j est initialisé à 10. b. Comme j est supérieur ou égal à 1 (10 > 1), on exécute la boucle (donc on affiche 10x10 = 100) puis on ajoute 1 à j (qui vaut donc 9). c. Comme j est supérieur ou égal 1 (9 > 1), on exécute la boucle (donc on affiche 10x9 = 90) puis on ajoute 1 à j (qui vaut donc 8). d. etc. On accélère jusqu à ce que j vaille 1. e. Comme j est supérieur ou égal à 1 (1=1), on exécute la boucle (donc on affiche 10x1 = 10) puis on ajoute 1 à j (qui vaut donc 0). f. Comme j est inférieur à 1, l exécution de la boucle j s arrête. On revient à la boucle i. 3. On ajoute 1 à i (qui vaut 9). 4. i étant supérieur ou égal à 1 (9 > 1), on exécute l instruction contenue dans la boucle soit une autre (avec le cas entier 1 > entier 2 ) : a. j est initialisé à 10. b. Comme j est supérieur ou égal à 1 (10 > 1), on exécute la boucle (donc on affiche 9x10 = 90) puis on ajoute 1 à j (qui vaut donc 9). c. Comme j est supérieur ou égal 1 (9 > 1), on exécute la boucle (donc on affiche 9x9 = 81) puis on ajoute 1 à j (qui vaut donc 8). d. etc. On accélère jusqu à ce que j vaille 1. e. Comme j est supérieur ou égal à 1 (1=1), on exécute la boucle (donc on affiche 9x1 = 9) puis on ajoute 1 à j (qui vaut donc 0). f. Comme j est inférieur à 1, l exécution de la boucle j s arrête. On revient à la boucle i. 5. On ajoute 1 à i (qui vaut 8). 6. etc. On accélère jusqu à ce que i vaille 1. Comme i est égal à 1, on exécute l instruction contenue dans la boucle soit une autre boucle (on affichera 1x10 = 10, 1x9 = 9 jusqu à 1x1 = 1). On ajoute 1 à i qui vaut i étant inférieur à 1, l exécution de la boucle est terminée. Les deux boucles sont dites imbriquées (l une est à l intérieur de l autre). Chaque itération de la boucle externe (ici i) entraîne l exécution complète de la boucle interne (ici j). Exercice 10 Appliquons le cours : 1. i est initialisé à 1 ; i étant inférieur à 5, on exécute le corps de la boucle (on affiche i soit 1 puis on retranche 1 à i qui vaut 0). 2. On ajoute 1 à i qui vaut 1 puis on recommence la boucle : comme i est inférieur à 5, on exécute le corps de la boucle (on affiche 1 et on retranche 1 à i qui vaut 0). 3. On ajoute 1 à i qui vaut 1 puis on recommence la boucle : comme i est inférieur à 5, on exécute le corps de la boucle (on affiche 1 et on retranche 1 à i qui vaut 0)

11 Variables et instructions Que se passe-t-il? La boucle ne s arrête jamais car à chaque itération le corps de boucle décrémente i que la boucle elle-même l incrémente. Cette instruction est assez illisible. Une règle non écrite veut que l on ne modifie pas «à la main» l indice de la boucle pour. Cet indice doit être utilisé uniquement en lecture, sinon on ne s y retrouve pas. Certains langages interdisent d ailleurs de modifier l indice. Pour nous, cela constituera une règle de validation. Exercice 11 Il suffit d appliquer le cours sur le pour : d abord on initialise l indice de boucle à 1 puis, tant que l indice est inférieur ou égal à 10, on exécute l instruction afficher et on incrémente l indice. Boucle tant que i := 1 tant que i <= 10 faire afficher i i := i+1 tant que Boucle répéter i := 1 répéter afficher i i := i+1 jusqu à i > 10 Vous remarquez que ces suites d instructions sont moins lisibles que le pour : il y a plus de lignes, la condition d arrêt est moins évidente et surtout il faut gérer soi-même l indice! Notez bien la symétrie des boucles tant que et répéter : les deux booléens sont la négation l un de l autre puisque dans un cas la boucle est terminée lorsque le test est vrai, et dans l autre cas, elle est terminée quand il est faux. Exercice 12 Vous ne vous attendez pas à un corrigé, n est-ce pas? Et bien, vous avez raison. Exercice 13 Dans l exercice 12, vous êtes en de paragraphe. Vous l avez donc lu une fois et, à l issue de cette lecture, vous devez décider de le relire ou non. 11

12 Séquence 1 Si l algorithme est présenté en de paragraphe, vous l exécuterez avant étude de ce dernier. Il doit donc vous dire de lire le paragraphe puis de vérifier votre assimilation. Cela donnera une boucle répéter : répéter faites une pause lisez le paragraphe 5 jusqu à ce que vous l ayez compris, ce satané paragraphe Cette correction n est pas parfaite car la boucle répéter n est pas adaptée. Le problème vient de la pause : dans l exercice 12, la pause est là pour vous éviter de boucler immédiatement sur une seconde lecture. En effet, si vous n avez pas compris le cours, il faut laisser passer un peu de temps pour que les choses décantent avant de recommencer ; pour obtenir le même résultat, je suis obligé de vous faire commencer par une pause. Pour sauver la face, nous dirons qu à la première itération, cette pause sépare les paragraphes 4 et 5. Exercice 14 C est simple, je dois employer une boucle pour. Pour i de 1 à 5 faire lire le paragraphe 5 faire une pause pour Exercice 15 Le fait de devoir lire 5 fois fait penser à un pour. Un peu de réflexion écartera cette instruction car on arrête la lecture dès que l on a compris. On lira donc le paragraphe 5 : tant que l on n a pas compris et que l on n a pas atteint les 5 lectures ; jusqu à ce que l on ait compris ou que l on ait atteint les 5 lectures. Vérifiez que ces deux formulations sont équivalenteså. Comme l algorithme doit être écrit en de paragraphe 5, une lecture a déjà été faite. Il faut donc tester immédiatement la compréhension puis passer à la suite ou relire (on dispose de 4 relectures puisque l on a droit à 5 lectures). å Vous noterez la transversalité de ce cours : je vous donne un bel exemple de concordance des temps. 12

13 Variables et instructions Cela donnera le code suivant : NumLecture := 1 // numéro courant de la lecture : on en a fait 1 tant que (le cours n est pas compris) et (NumLecture < 5) faire faire une pause relire le paragraphe 5 NumLecture := Numlecture +1 tant que Voyez bien que l on quitte la boucle lorsque son test est faux, à savoir dès que l une des deux conditions suivantes est fausse : le cours n est pas compris ; le nombre de lectures faites est inférieur à 5. Dit autrement, on quitte la boucle lorsque son test est faux, à savoir dès que l une des deux conditions suivantes est vraie : le cours est compris ; le nombre de lectures faites est égal à 5. Exercice 16 Nous avons vu dans l exercice 11 qu une boucle pour pouvait s écrire sous forme d un tant que ou d un répéter. La difficulté est donc de choisir la bonne instruction! Analysons le problème : pour chaque heure de 0 à 23 on veut afficher les minutes de 0 à 59. Et bien, cela nous fera deux boucles pour imbriquées : Algorithme trois_mille_six_cent_fois_par_heure_la_seconde_chuchote_souviens_toi h,m : entier pour h de 0 à 23 pour m de 0 à 59 afficher h, ":", m pour pour Je n ai pas vu la difficulté annoncée, M. Février. Suis-je passé à côté? Bah, si vous ne l avez pas vue, c est qu en effet vous l avez loupée. Que se passe-t-il lorsque l on pense afficher 08 :05? Eh bien, on affiche 8:5. En effet, l entier 8 s affiche 8 et non 08 (sinon, pourquoi ne pas l afficher ou pire encore?). Nous allons rajouter des alternatives pour prendre en compte les valeurs inférieures à 10 et les précéder d un zéro. 13

14 Séquence 1 Algorithme trois_mille_six_cent_fois_par_heure_la_seconde_chuchote_souviens_toi h,m : entier pour h de 0 à 23 pour m de 0 à 59 si h < 10 afficher "0" si afficher h, ":" si m < 10 afficher "0" si afficher m pour pour Le code est déjà nettement moins lisible, mais l affichage sera impeccable! Notez que je ne me soucie pas du retour à la ligne. 14

15 Séquence 2 Procédures et fonctions Exercice 17 C est un passage par valeur (il n y a pas de ). Pour l affichage du programme et la suite de l exercice, retournez dans le cours. Exercice 18 Nous écrivons une fonction renvoyant le nombre le plus grand. La modification éventuelle des paramètres ne doit pas avoir d incidence dans les iables du programme principal. On réalise donc un passage par valeur. Algorithme maximum e1, e2 : entier fonction Maximum (a : entier, b : entier) : entier si a > b Retourner (a) sinon Retourner (b) si saisir "Entrez le premier nombre", e1 saisir "Entrez le second nombre", e2 afficher "Nombre le plus grand : ", Maximum (e1, e2) On pouvait passer par une iable intermédiaire dans la fonction : fonction Maximum (a : entier, b : entier) : entier c : entier si a > b 15

16 Séquence 2 c := a sinon c := b si Retourner (c) (Le reste du code est inchangé.) Exercice 19 Je vais faire deux fonctions : une pour la remise et une pour le port. De quelles données ai-je besoin? Vu le sujet, uniquement du nombre d articles et du total de la commande. Il est notamment inutile de saisir le nom des produits commandés ou leur prix. Voici l algorithme : Algorithme commande NbrArticles : entier TotalCommande : réel Port : réel Remise : réel fonction CalculRemise (NombreArticles : entier, TotCom : réel) : réel selon NombreArticles cas 1, 2 : Retourner (0) cas 3, 4 : Retourner (TotCom*0.05) cas 5, 6, 7 : Retourner (TotCom*0.1) cas sinon : Retourner (TotCom*0.15) selon fonction CalculPort (TotalAvecRemise : réel) : réel si TotalAvecRemise < 77 Retourner (7,7) sinon si TotalAvecRemise <= 150 Retourner (4) sinon Retourner (0) 16

17 Procédures et fonctions si si saisir "Nombre d articles achetés :", NbrArticles saisir "Total commande :", TotalCommande Remise := CalculRemise (NbrArticles, TotalCommande) afficher "Remise : ", Remise Port := CalculPort (TotalCommande-Remise) afficher "Port : ", Port afficher "Net à payer : ", TotalCommande-Remise+Port Les différents montants doivent être des nombres réels. Notez que CalculPort ne peut être réalisé qu avec un si et pas un selon cas car TotalAvecRemise est un réel. Pour chaque sous-programme, il faut s assurer de n utiliser que les paramètres nécessaires. De plus, les fonctions commençant à être complexes, il est indispensable de vérifier pour chacune que, quelle que soit son exécution dépendant des alternatives incluses, on exécute une instruction Retourner. Exercice 20 Remarque liminaire : si les valeurs sont égales, je peux renvoyer indifféremment l une ou l autre. Je n ai donc pas à me soucier de ce cas. La fonction : fonction Minimum (a : entier, b : entier) : entier si a < b Retourner (a) sinon Retourner (b) si Exemple d utilisation de la fonction : z := Minimum (i, 5) 17

18 Séquence 2 Sous forme de procédure, cela donne : procédure Minimum (a : entier, b : entier, Résultat : entier) si a < b Résultat := a sinon Résultat := b si Notez bien que le nom du nouveau paramètre est totalement arbitraire. J ai mis Résultat car c est un nom cohérent (je renvoie bien un résultat) mais tout autre nom restait acceptable. J ai d ailleurs hésité avec Min. Minimum n est pas utilisable car il est déjà pris : c est le nom de la procédure. Exemple d utilisation de la procédure : Minimum (i, 5, z) Exercice 21 Le corrigé est dans la suite du cours. 18

19 Séquence 3 Tableaux, structures et types Exercice 22 1) 60 étudiants et moyenne annuelle. Je vais stocker 60 valeurs réelles, soit : NotesBTS : tableau[60] de réels 2) 2 classes de BTS de 30 étudiants chacune. Je choisis d identifier la classe (premier indice) puis l étudiant dans la classe (second indice). J ai toujours 60 valeurs, mais sous la forme deux fois trente : NotesBTS : tableau[2, 30] de réels Je choisis d indicer d abord la classe puis l étudiant car cela me semble plus logique vu le réel modélisé. L inverse (soit tableau[30,2]) est possible comme nous l avons vu dans le cours. L important est de choisir une version et de s y tenir. 3) 2 classes de BTS de 30 étudiants chacune, 20 notes. Je choisis d identifier la classe (premier indice, vaudra 1 ou 2) puis l étudiant dans la classe (deuxième indice, de 1 à 30) et en la note (troisième indice, allant de 1 à 20). J ai 2 classes x 30 étudiants x 20 notes soit valeurs : NotesBTS : tableau[2, 30, 20] de réels Par exemple, la dernière note (soit la 20 e ) de l étudiant numéro 12 qui est en 2 e année sera : NotesBTS[2 e année, étudiant 12, dernière note] soit NotesBTS[2, 12, 20]. Exercice 23 1) 2 classes de BTS de 30 étudiants chacune, 2 semestres, 10 notes par semestre. Je choisis d identifier la classe (premier indice) puis l étudiant dans la classe (deuxième indice) puis le semestre (troisième indice) et en la note (quatrième indice). J ai 2 classes x 30 étudiants x 2 semestres x 10 notes soit valeurs : NotesBTS : tableau[2, 30, 2, 10] de réels 19

20 Séquence 3 2) 2 classes de BTS de 30 étudiants chacune, 2 semestres, 11 matières et 10 notes par semestre. Pour la première fois, j ai vraiment le choix de l ordre des indices en fonction de mes perceptions. Les quatre ordres suivant ont un sens : classe, étudiant, semestre, matière et en note ; classe, étudiant, matière, semestre, et en note ; classe, semestre, étudiant, matière et en note ; classe, semestre, matière, étudiant, et en note ; Encore une fois, tout dépend ce que je veux mettre en avant. Si je gère des étudiants qui ont des notes, ce sera l un des deux premiers choix. S il me semble plus lisible de choisir la période scolaire (année puis semestre) avant l étudiant, ce sera l une des deux dernières solutions. Encore une fois, n importe laquelle des quatre versions est correcte et me permettra de faire tous les traitements que je désire. Je vais choisir la troisième proposition, soit classe (indice maximum 2), semestre (indice maximum 2), étudiant (indice maximum 30), matière (indice maximum 11) et en note (indice maximum 10) : NotesBTS : tableau[2, 2, 30, 11, 10] de réels 3) 2 BTS Il me suffit de rajouter un indice (je le mettrai en premier) valant 1 pour BTS IG et 2 pour BTS NRC : NotesBTS : tableau[2, 2, 2, 30, 11, 10] de réels Il est bien évident que, pour pouvoir utiliser un tableau, vous devez connaître le rôle de chaque indice. Les trois premiers indices du tableau ci-dessus vont de 1 à 2. Il est impossible de deviner lequel représente la classe, le semestre ou le BTS. Exercice 24 La troisième note d économie (8 e matière) du premier semestre pour l étudiant 17 en seconde année de BTS IG (1 er BTS)? En remettant mes critères dans l ordre des indices, cela donne : NotesBTS[bts ig, seconde année, premier semestre, étudiant 17, matière 8, note 3] La réponse est donc NotesBTS[1, 2, 1, 17, 8, 3]. Les notes d économie au troisième contrôle du premier semestre pour tous les étudiants de seconde année de BTS IG? Je prends en compte tous les étudiants et non plus le 17 e uniquement. Je vais donc devoir faire ier le 4 e indice sur toute sa plage de valeurs, soit de 1 à 30. Les notes voulues seront donc accessibles par NotesBTS[1, 2, 1, 1, 8, 3], NotesBTS[1, 2, 1, 2, 8, 3],, NotesBTS[1, 2, 1, 30, 8, 3]. 20

21 Tableaux, structures et types Pour faire ier cet indice, j utiliserai une boucle pour allant de 1 à 30. Pour simplifier l écriture, je vais remplacer l indice en question par une étoile («*»). Cela représentera que toutes les valeurs possibles (donc de 1 à 30) doivent être considérées. Cela donne donc en condensé : NotesBTS[1, 2, 1, *, 8, 3]. Les notes d économie au premier semestre pour tous les étudiants de seconde année de BTS IG? Non seulement je prends en compte tous les étudiants, mais je considère en plus toutes les notes et non uniquement la troisième. Comme j ai 10 notes et 30 étudiants, cela englobe 300 éléments de NotesBTS. Vous les trouverez en faisant ier l indice des étudiants (le quatrième) dans toute sa plage de 1 à 30 et, pour chacune des valeurs, en faisant ier l indice des notes (le dernier) sur toute sa plage de 1 à 10. Par programmation, nous ferions deux boucles imbriquées. Avec notre notation étoile, cela donne en condensé : NotesBTS[1, 2, 1, *, 8, *]. Les notes d économie au premier semestre pour tous les étudiants de BTS IG? Non seulement je prends en compte tous les étudiants et toutes les notes, mais je considère en plus les deux années de BTS IG et non uniquement la seconde. Comme j ai 10 notes, 30 étudiants et deux années, cela englobe 600 éléments de NotesBTS. Vous les trouverez en faisant ier l indice des années de BTS IG (le deuxième) dans toute sa plage de 1 à 2 et, pour chacune des valeurs, en faisant ier l indice des étudiants (le quatrième) dans toute sa plage de 1 à 30 et, pour chacune des valeurs, en faisant ier l indice des notes (le dernier) sur toute sa plage de 1 à 10. Par programmation, nous ferions trois boucles imbriquées. Avec notre notation étoile, cela donne en condensé : NotesBTS[1, *, 1, *, 8, *]. Les notes d économie au premier semestre pour tous les étudiants, tous BTS confondus? Je ne détaille plus. Il faut, en plus du cas précédent, faire ier le premier indice représentant le BTS, soit : NotesBTS[*, *, 1, *, 8, *]. On utiliserait quatre boucles imbriquées. Les notes d économie, toute classe, semestre et étudiant confondus? Je ne détaille plus. Il faut, en plus du cas précédent, faire ier le troisième indice représentant le semestre, soit : NotesBTS[*, *, *, *, 8, *]. Exercice 25 Il me faut cinq boucles imbriquées. Le «sous-programme qui généralise» du sujet signifie que je vais passer en paramètre le tableau et le numéro de la matière dont je veux la moyenne. Cela me permet de calculer la moyenne de n importe quelle matière. 21

22 Séquence 3 Voici le code : fonction MoyenneMatière (Note : tableau[2,2,2,30,11,10] de réels, NumMatière : entier) : réel Bts, Année, Semestre, Étudiant, Note : entier Cumul : réel Cumul := 0 pour Bts de 1 à 2 faire pour Année de 1 à 2 faire pour Semestre de 1 à 2 faire pour Étudiant de 1 à 30 faire pour Note de 1 à 10 faire Cumul := Cumul + Note[Bts, Année, Semestre, Étudiant, NumMatière, Note] pour pour pour pour pour Retourner (Cumul/2400) La moyenne des notes d une matière, c est bien la somme des notes de cette matière divisée par le nombre total de notes de la matière, soit 2*2*2*30*10 soit Il est possible de compter le nombre de notes dans les boucles : Ok pour le paramètre? Il détermine la matière. fonction MoyenneMatière (Note : tableau[2,2,2,30,11,10] de réels, NumMatière : entier) : réel Bts, Année, Semestre, Étudiant, Note : entier Cumul : réel NbrNotes : entier Cumul := 0 NbrNotes := 0 pour Bts de 1 à 2 faire pour Année de 1 à 2 faire pour Semestre de 1 à 2 faire pour Étudiant de 1 à 30 faire pour Note de 1 à 10 faire Cumul := Cumul + Note[Bts, Année, Semestre, Étudiant, NumMatière, Note] 22

23 Tableaux, structures et types NbrNotes := NbrNotes + 1 pour pour pour pour pour Retourner (Cumul/NbrNotes) C est moins efficace car on doit effectuer additions supplémentaires. Mais cela évite les erreurs de calcul. Pour éviter les erreurs et rester efficace, l instruction Retourner de la première fonction pouvait s écrire : Retourner (Cumul/(2*2*2*30*10)) On comprend parfaitement ce que représente le chiffre divisant Cumul. Synchronisons-nous. Pour afficher la moyenne des notes d économie, il faut appeler la fonction. Si notre tableau s appelle NotesBTS, on écrira : Afficher MoyenneMatière(NotesBTS, 8) Exercice 26 Si vous considérez que «3,4» est un nombre réel, vous voulez accéder à un élément dont l indice n existe pas. En effet, l indice est un entier. D ailleurs, comme dans ce cours l indice est la position de l élément, il est évident que la position 3,4 n a pas de sens. Si vous considérez qu un indice ne pouvant être qu entier, «3,4» constitue l accès à un élément dans un tableau à deux dimensions (genre «ligne 3, colonne 4»), cela ne fonctionne toujours pas puisque notre tableau ne possède qu une dimension. Exercice 27 C est le même principe que pour l exercice précédent : notre écriture n a aucun sens puisque le tableau a deux dimensions. N en fournir qu une ne veut rien dire. D ailleurs, laquelle des deux a-t-on fourni ici? Mystère. Exercice 28 Voici un exercice intéressant. Débarrassons-nous d un point sans importance : je suppose que je relève les températures au degré près. Je manipule donc des entiers. Si vous alliez au demi-degré près, vous utiliseriez des réels mais cela ne change strictement rien à notre propos. Dans une année, nous avons 365 jours. En parfois, c est 366. Bien entendu, il faut prévoir tous les cas et prendre le plus défavorable. Nous aurons donc besoin de stocker 366 valeurs (une étant parfois inutilisée). 23

24 Séquence 3 La première idée est de déir un tableau temp (pour température) à une dimension : temp : tableau[366] d entiers Ce tableau permet de stocker les températures. Mais est-il pratique d emploi? Pas du tout! Il ne répond pas à mon attente : comment récupérer les températures de févrierå? celles de l hiver? Il me faudrait connaître les indices de chaque jour. Or, si je sais que l hiver e le 23 décembre, je ne sais pas quel est le rang de ce jour (entre 1 et 366). La déition d un tableau doit toujours être faite sérieusement et en fonction de l usage futur. Dans notre cas, je souhaite pouvoir distinguer les mois. Il est donc beaucoup plus raisonnable de déir un tableau à deux dimensions, la première représentant le jour et l autre le mois. temp : tableau [31,12] d entiers La température du 17 février est stockée dans temp[17,2]. Notez que l on retrouve le problème de l année bissextile : comme certains mois ont 31 jours, il faut réserver 31 valeurs pour chacun. Pour ceux à 28 ou 30 jours, tant pis nous aurons des éléments inutilisées (par exemple temp[30,2]). Mais bon, on gaspille 31* soit 6 éléments, ce qui est très peu. Et, de toute façon, on n a pas le choix. Exercice 29 Le problème posé par la boucle est celui déjà évoqué dans l exercice précédent : tout tableau est rectangulaire (toutes les lignes ont le même nombre d éléments). Or, nos mois n ont pas tous autant de jours : certains en ont 30, d autres 31 et un en a 28 ou 29. Ainsi, faire une boucle de 1 à 31 n ira pas pour les mois de 30 jours : on prendra en compte un élément du tableau n ayant aucune valeur déie. Se limiter à une boucle de 1 à 30 n est pas plus efficace car on ne prendra pas en compte le dernier jour des mois qui en comptent 31. L idée est donc de faire une boucle allant de 1 à NbrJours(i), i étant le mois considéré. NbrJours est une fonction ; si on veut en faire un tableau, on écrira NbrJours[i]. Exercice 30 En entrée, la fonction a besoin du numéro de mois dont on veut connaître le nombre de jours. Elle renvoie le nombre en question. Le plus simple est d utiliser un selon cas. å Ne confondez pas les températures de février avec la température de Février. Merci. 24

25 Tableaux, structures et types fonction NbrJours (NumMois : entier) : entier selon NumMois cas 2 : Retourner (28) cas 4, 6, 9, 11 : Retourner (30) cas sinon : Retourner (31) selon Exercice 31 Nous avons besoin d un tableau à une dimension et 12 éléments (l élément d indice i contenant le nombre de jours du mois i). NbrJours : tableau[12] d entiers Pour initialiser ce tableau, il faut une procédure recevant le tableau non initialisé et le retournant initialisé. On passe donc le paramètre tableau par adresse. procédure InitNbrJours ( t : tableau[12] d entiers) NumMois : entier pour NumMois de 1 à 12 selon NumMois cas 2 : t[nummois] := 28 cas 4, 6, 9, 11 : t[nummois] := 30 cas sinon : t[nummois] := 31 selon pour Notez au passage que je viens d écrire un sous-programme autonome. Je peux maintenant le placer dans un programme quelconque pour m en servir. Exercice 32 Le sous-programme sera une fonction puisque je souhaite récupérer un résultat (qui sera un réel). Les valeurs en entrée seront le tableau contenant les températures et le numéro du mois souhaité, toutes par valeur. 25

26 Séquence 3 fonction TempMoyenneMois (t : tableau[31,12] d entiers, Mois : entier) : réel Jour, Cumul : entier Cumul := 0 pour Jour de 1 à NbrJours(Mois) Cumul := Cumul + t[jour,mois] pour Retourner (Cumul/NbrJours(Mois)) Voici comment nous appellerons cette fonction : Saisir "Quel mois voulez-vous étudier? ", m Affichage "Moyenne du mois demandé : ", TempMoyenneMois(Temp, m) Temp est le tableau déi dans l exercice 28. Arrivé en seconde année, la difficulté est éventuellement l en-tête de la fonction, mais surtout pas le calcul de la moyenne. (En, j espère!) Exercice 33 Le sous-programme sera une fonction puisque je souhaite récupérer un résultat (réel). Les valeurs en entrée seront le tableau contenant les températures, celui contenant le nombre de jours par mois et le numéro du mois souhaité. Ces trois paramètres sont toutes les informations nécessaires au sous-programme. Aucune iable globale n est nécessaire. Cela permet d utiliser cette fonction partout où on le désire. fonction TempMoyenneMois (t : tableau[31,12] d entiers, NbrJours : tableau[12] d entiers, Mois : entier) : réel Jour, Cumul : entier Cumul := 0 pour Jour de 1 à NbrJours[Mois] Cumul := Cumul + t[jour,mois] pour Retourner (Cumul/NbrJours[Mois]) Voici comment nous appellerons cette fonction (on suppose que les tableaux Temp et TNbrJ sont déis correctement). InitNbrJours (TNbrJ) // exercice 31 Saisir "Quel mois voulez-vous étudier? ", m Affichage "Moyenne du mois demandé : ", TempMoyenneJours (Temp, TNbrJ, m) 26

27 Tableaux, structures et types Exercice 34 Il n y a pas de difficulté particulière. type Client = structure NumClient : entier NomClient : chaîne PrénomClient : chaîne AdrClient : chaîne TélClient : chaîne DateClient : date structure Exercice 35 Voir la suite du cours. Exercice 36 Avec une procédure (la structure est évidemment passée par adresse). procédure InitClient ( C : Client) saisir "Entrez le numéro : ", C.NumClient saisir "Entrez le nom : ", C.NomClient saisir "Entrez le prénom : ", C.PrénomClient saisir "Entrez l adresse : ", C.AdrClient saisir "Entrez le téléphone : ", C.TélClient saisir "Entrez la date de première commande : ", C.DateClient Voici comment on s en sert : Cl : Client InitClient (Cl) 27

28 Séquence 3 Avec une fonction : fonction InitClient : Client Cl : Client saisir "Entrez le numéro : ", Cl.NumClient saisir "Entrez le nom : ", Cl.NomClient saisir "Entrez le prénom : ", Cl.PrénomClient saisir "Entrez l adresse : ", Cl.AdrClient saisir "Entrez le téléphone : ", Cl.TélClient saisir "Entrez la date de première commande : ", Cl.DateClient Retourner (Cl) Notez bien l astuce : on crée une iable temporaire Cl que l on retourne en résultat. La iable Cl sera supprimée dès que l on quittera la fonction mais le résultat est préservé. Vous remarquerez que cette fonction ne possède aucun paramètre. Voici comment on s en sert : Client1 : Client Client1 := InitClient() Certains langages proposent de mettre des parenthèses vides pour bien montrer que l on fait un appel de fonction sans paramètre. Je conserve cette notation car ne pas mettre de parenthèses pourrait faire croire que InitClient est une iable. Exercice 37 Voici le tableau et sa iable : Âge : tableau[40] d entiers NbrÂges : entier Le sous-programme sera forcément une procédure car nous devons modifier deux iables : le tableau et la iable contenant son nombre d éléments. Les deux seront passées par adresse. Autre difficulté, comment renvoyer des valeurs aléatoires entre 18 et 23 ans? Et bien, il suffit de résoudre une inéquation : 0 aléatoire (i) i-1, soit : 18 aléatoire (i) +18 (i-1) + 18 Or, on veut une borne maximale de 23, soit (i-1)+18 = 23 soit i = 6. 28

29 Tableaux, structures et types Au al : 18 aléatoire (6) Nous avons notre formule. Voici le sous-programme : procédure InitAléat35 ( t : tableau[40] d entiers, NbrT : entier) i : entier pour i de 1 à 35 t[i] := aléatoire(6)+18 pour NbrT := 35 Pour initialiser mes iables, j écrirai : InitAléat35 (Âge, NbrÂges) Exercice 38 Le sous-programme sera une fonction prenant en entrée le tableau et son nombre d éléments et retournant la valeur moyenne. Les paramètres sont passés par valeur car on ne souhaite pas les modifier. fonction MoyenneTab (t : tableau[40] d entiers, NbrT : entier) : réel Somme : entier Somme := 0 pour i de 1 à NbrT Somme := Somme + t[i] pour Retourner (Somme/NbrT) Exercice 39 La déclaration ne doit poser aucune difficulté : type TableauÂge = structure Élément : tableau[40] d entiers NbrÉléments : entier structure (Les noms sont un peu arbitraires.) 29

30 Séquence 3 Je déclare ensuite une iable : Bts1 : TableauÂge Cette iable Bts1 correspond logiquement à ma classe de BTS 1 re année. Pour accéder à un élément du tableau, voir la suite du cours. Exercice 40 Il ne faut pas confondre le type et la iable. Le type TableauÂge est un concept abstrait, comme la notion d entier. Ce type ne contient donc pas de valeur, de tableau ou de iable. Il dit juste qu une iable de ce type contiendra un tableau de quarante entiers appelé Élément et un entier appelé NbrÉléments. Le tableau Élément ne peut donc appartenir qu à une iable de type TableauÂge. Réciproquement, toute iable de type TableauÂge contient un tableau Élément. Vu mon sujet, il est évident que je fais référence au tableau Élément de la iable Bts1 (de type TableauÂge). Exercice 41 Voici les deux sous-programmes. Voyez bien l intérêt de la structure : nous n avons plus qu une seule iable en paramètre. J ai mis les changements en gras. procédure InitAléat35 ( Classe : TableauÂge) i : entier pour i de 1 à 35 Classe.Élément[i] := aléatoire(6)+18 pour Classe.NbrÉléments := 35 fonction MoyenneTab (Classe : TableauÂge) : réel Somme : entier Somme := 0 pour i de 1 à Classe.NbrÉléments Somme := Somme + Classe.Élément[i] pour Retourner (Somme/Classe.NbrÉléments) Si Bts1 est de type TableauÂge, nous utiliserons ces sous-programmes ainsi : InitAléat35 (Bts1) Afficher MoyenneTab(Bts1) 30

31 Tableaux, structures et types Exercice 42 Il ne doit pas y avoir de difficulté. Je reprends tous les types dont j ai besoin : type Client = structure NumClient : entier NomClient : chaîne PrénomClient : chaîne AdrClient : chaîne TélClient : chaîne DateClient : date structure TabClient = structure Élément : tableau[1000] de Client NbrClients : entier structure Notez que j enchaîne les déclarations de types après le mot clé type, de même que l on enchaîne les déclarations de iables après le mot clé. Je me limite à clients car le sujet précise que je n irai pas au-delà. Exercice 43 Le sous-programme sera une procédure puisqu il s agit d afficher des informations, pas de renvoyer un résultat. Le principe est simple : je parcours le tableau du premier au dernier élément (que l on connaît par NbrClients) et j affiche le champ NomClient de chaque élément. procédure AffichageNom (TC : TabClient) i : entier pour i de 1 à TC.NbrClients Afficher TC.Élément[i].NomClient pour Expliquons le code : dans la structure TC, je veux accéder au tableau, donc TC.Élément ; à partir du tableau, je veux l élément i, soit TC.Élément[i]. Notez bien que TC.Élément[i] fait référence à une iable de type Client ; dans la iable structurée TC.Élément[i], je souhaite obtenir le nom. J écrirai TC.Élément[i].NomClient. Finalement, TC est une structure contenant un tableau de structures. 31

32

33 Travaux dirigés 1 Exercice 1 Nous aurons une fonction prenant en paramètre par valeur une structure de type TabClient et retournant un entier. Le principe de l algorithme est simple : on va du premier au dernier élément du tableau et on incrémente une iable initialement nulle à chaque fois que l on rencontre un client habitant Aubusson. Aller du premier au dernier élément d un tableau impose l emploi d une boucle pour. N oubliez pas que le nombre d éléments est stocké dans le champ NbrClients. fonction Aubusson (TC : TabClient) : entier Nbr, i : entier Nbr := 0 pour i de 1 à TC.NbrClients si TC.Élément[i].AdrClient = "Aubusson" Nbr := Nbr + 1 si pour Retourner (Nbr) Notez bien l accès au champ AdrClient : dans la structure TC, je veux accéder au tableau (donc TC.Élément), dans le tableau, à l élément i (donc TC.Élément[i]) et, dans cet élément qui est une iable de type Client, j accède au champ voulu, soit TC.Élément[i].AdrClient. Comment passer de la fonction Aubusson à un sous-programme plus général fonctionnant avec n importe quelle ville? Il suffit de passer la ville en paramètre! (En gras ce qui change.) fonction NbrVille (TC : TabClient, Ville : chaîne) : entier Nbr, i : entier Nbr := 0 pour i de 1 à TC.NbrClients si TC.Élément[i].AdrClient = Nbr := Nbr + 1 si pour Retourner (Nbr) Ok? J utilise le paramètre Ville À retenir : Parcours d un tableau du à la boucle pour. 33

34 Exercice 2 Dans tous les cas, le sous-programme sera une fonction prenant en paramètre une structure de type TabClient et le numéro du client cherché et retournant une chaîne de caractères (soit un résultat du type du champ NomClient). L en-tête sera : fonction RechercheClient (TC : TabClient, Numéro : entier) : chaîne Quelle différence aurons-nous dans l algorithme selon que le client existe forcément ou non? Voici le principe des algorithmes dans les deux cas : si le client existe, nous parcourrons le tableau jusqu à ce qu on le trouve ; si le client peut ne pas exister, nous le parcourrons jusqu à le trouver ou arriver en de tableau. Dans les deux cas, on utilise une boucle tant que. Le client existe fonction RechercheClient (TC : TabClient, Numéro : entier) : chaîne i : entier i = 1 tant que TC.Élément[i].NumClient <> Numéro faire i := i+1 tant que Retourner (TC.Élément[i].NomClient) Comprenez bien cet algorithme : avec la iable i servant d indice de tableau, on va se positionner sur le client voulu (tant que l on n est pas sur le bon client, on avance d un élément). Notez que je ne me préoccupe pas du nombre d éléments du tableau car je suis certain de trouver ce que je cherche. On sort de la boucle tant que quand le test est faux, soit quand TC.Élément[i].NumClient <> Numéro est faux, donc quand TC.Élément[i].NumClient = Numéro. Je peux initialiser directement le résultat puisque je sais que je suis sur le bon élément. Le client n existe pas forcément L algorithme précédent n est plus acceptable. En effet, si le client cherché n existe pas, la boucle continuera indéiment. À force d augmenter, l indice i va sortir du tableau. Cela posera de gros problèmes! Je suis donc obligé de rajouter une condition dans ma boucle : elle s arrête lorsque je trouve le bon élément ou lorsque je suis à la du tableau. 34

35 Voici la nouvelle boucle : tant que TC.Élément[i].NumClient <> Numéro et i < TC.NbrClients faire i := i+1 tant que Vérifions qu elle fonctionne bien, à savoir que je ne dépasse jamais le dernier élément du tableau. Je me positionne sur le premier, puis le deuxième jusqu à l avant-dernier élément du tableau (en supposant évidemment que je n aie toujours pas trouvé mon élément). Sur l avant-dernier élément, mon test est toujours vrai (i vaut TC.NbrClients-1). J incrémente donc i qui vaut TC.NbrClients. Je suis sur le dernier élément du tableau. Dans ce cas, mon test est systématiquement faux (i n est plus inférieur à TC.NbrClients) donc je sors de la boucle. Finalement, je peux sortir de la boucle dans trois cas : j ai trouvé mon client (TC.Élément[i].NumClient = Numéro) ; je suis sur le dernier élément du tableau (i = TC.NbrClients) et je n ai pas trouvé mon client ; je suis sur le dernier élément du tableau et il contient le client que je cherche. Tout cela pour dire que je peux sortir de la boucle pour deux raisons totalement différentes : car j ai trouvé mon client ou parce que j ai atteint la du tableau sans le trouver. Je vais donc devoir rajouter un test pour vérifier dans quelle situation je suis. si TC.Élément[i].NumClient = Numéro Retourner (TC.Élément[i].NomClient) sinon Retourner ("") si Pour que le programme appelant mon sous-programme sache interpréter le résultat, je prends la convention suivante : si le client n existe pas, je renvoie une chaîne vide ; s il existe, je renvoie son nom. Comme un client porte forcément un nom, il n y aura aucune ambiguïté. Le programme appelant testera le résultat et s adaptera en conséquence. 35

36 Voici la fonction ale (en gras ce qui a changé) : fonction RechercheClient (TC : TabClient, Numéro : entier) : chaîne i : entier i = 1 tant que TC.Élément[i].NumClient <> Numéro et i < TC.NbrClients faire i := i+1 tant que si TC.Élément[i].NumClient = Numéro Retourner (TC.Élément[i].NomClient) sinon Retourner ("") si Notez qu après la boucle, je teste l existence de l élément et non l arrivée en de tableau. Pourquoi? Car c est la première condition qui l emporte. Si je suis en de tableau (sur le dernier élément) et que ce dernier élément est celui que je cherchais, je suis dans la situation où je l ai trouvé. La fonction est nettement plus longue et technique : il faut prendre son temps et vérifier, comme nous l avons fait, que le test est correct. Sans précision sur l existence du client Il faut toujours prendre le cas général (à savoir le plus défavorable). Sans indication dans un sujet, vous devez estimer que l élément cherché n est pas forcément présent. À retenir : parcours d un tableau pour chercher un élément boucle tant que ; si l élément n est pas forcément présent, il faut tester l arrivée en de tableau dans la boucle puis, en sortie de boucle, tester si l on est sorti car on avait trouvé l élément ou parce que l on était en de tableau. Exercice 3 Le client le plus ancien (ou le plus machin, ou le moins truc) existe toujours. De plus, il faut parcourir tout le tableau pour être sûr de le trouver. On est donc face à un mélange des deux exercices précédents. On utilisera une boucle pour a de parcourir tout le tableau. Le principe sera le suivant : on va dire que le premier client est le plus ancien (temporairement). On va ensuite parcourir tout le tableau, du deuxième au dernier élément. On comparera successivement le client courant avec celui temporairement le plus ancien. Si le client courant est plus ancien, il devient celui temporairement le plus ancien. Et cela jusqu au bout. En de parcours, le client temporairement le plus ancien est réellement le plus ancien. 36