Qu’est-ce qu’un algorithme ? Les algorithmes sont partout dans la technologie qui nous entoure : téléphones portables, ordinateurs, internet,… Bien évidemment le présent manuel, introduction aux bases de l’algorithmique, ne prétend pas expliquer le fonctionnement d’un smartphone. Mais une initiation au fonctionnement des algorithmes est une clé utile à la compréhension du monde actuel. Le mot « Algorithme » vient du nom du mathématicien perse Al-Khwârizmî (environ 780-850 après JC). Un algorithme est une succession d’instructions permettant la résolution d’un problème donné. Il comporte jusqu'à quatre étapes (généralement dans cet ordre mais ce n'est pas toujours le cas) : Entrée(s) : On entre les données, cela permet de réutiliser plusieurs fois l'algorithme avec plusieurs valeurs différentes Initialisation(s) : On entre la valeur de départ de certaines variables, lorsque celles-ci sont toujours les mêmes au début de l'algorithme. Traitement : Le "cœur" de l'algorithme, on travaille les données pour obtenir le résultat voulu. Sortie(s) : Affichage du ou des résultats. Cela fonctionne donc un peu à la manière d’une recette de cuisine : nous avons à notre disposition des ingrédients (données entrées) que nous mélangeons, cuisons (étape de traitement), pour obtenir notre plat (résultat de sortie). Toutes les étapes ne sont pas toujours présentes dans un algorithme, il arrive fréquemment qu'il n'y ait pas, par exemple, d'étape d'initialisation. De plus il peut y avoir plusieurs fois la même étape dans un seul algorithme (par exemple plusieurs étapes de sortie). Un algorithme peut être écrit en langage naturel, en langage algorithmique ou en langage de programmation (pour une calculatrice ou un ordinateur). Le langage naturel est l’écriture de l’algorithme sous forme de phrases intelligibles. Le langage algorithmique est une écriture plus efficace, car plus concise, de l’algorithme. Il est une sorte de résumé du langage naturel (lorsqu’il y a un langage naturel). Les actions de base du langage algorithmique sont : Saisir, affecter, afficher, calculer … (liste non exhaustive). Le langage de programmation est la « traduction » du langage algorithmique à l’aide des commandes disponibles sur la machine sur laquelle on veut le programmer. Dans ce manuel nous utiliserons exclusivement le langage de programmation CASIO pour les Graph 35+E, Graph 75+E ou fx-CP400+E. Il est à noter que les programmes réalisés sur la Graph 75+E peuvent être réalisés de la même manière sur la Graph 35+E (et inversement) étant donné que les langages de programmation de ces deux machines sont équivalents. 1 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Langage Langage Langage Graph 35+E Langage naturel algorithmique et Graph 75+E fx-CP400+E Entrer la valeur de X Saisir X ?՜X Input X Annoncer la valeur de X Afficher X X Print X X prend la valeur 2 Affecter 2 à X 2՜X 2֜X Afficher un message Afficher "message" "message" Print "message" Retrouvez tous nos programmes en téléchargement gratuit sur : www.casio-education.fr/resources 2 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E SOMMAIRE I. PREMIERS ALGORITHMES : PROGRAMMES DE CALCUL........................................................................ 4 II. AFFECTATION ....................................................................................................................................................... 6 III. STRUCTURE CONDITIONNELLE .................................................................................................................. 7 IV. BOUCLES ........................................................................................................................................................... 9 V. 1. Boucles Pour ......................................................................................................................................................... 9 2. Boucles Tant que ................................................................................................................................................. 11 Vers un peu plus de complexité ......................................................................................................................... 14 Exemple 1 : Année bissextile. ..................................................................................................................................... 14 Exemple 2 : Suite de Fibonacci.................................................................................................................................... 15 Exemple 3 : Méthode de Monte-Carlo ....................................................................................................................... 16 Exemple 4 : Suite de Syracuse..................................................................................................................................... 19 Exemple 5 : Algorithme de Kaprekar .......................................................................................................................... 20 Exemple 6 : Nombres parfaits ..................................................................................................................................... 21 Exemple 7 : Algorithme de tri ..................................................................................................................................... 23 Exemple 8 : Convertisseur système binaire. ............................................................................................................... 24 Exemple 9 : Marche aléatoire "A consommer avec modération" .............................................................................. 25 Exemple 10 : La fractale du vieux chien (D'après D. Hidra) ........................................................................................ 28 Exemple 11: Suite de Conway revisitée ...................................................................................................................... 30 Exemple 12 : Jeu de mémoire ..................................................................................................................................... 33 Exemple 13 : Développements Limités ....................................................................................................................... 39 3 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E I. PREMIERS ALGORITHMES : PROGRAMMES DE CALCUL Les programmes de calcul, vus depuis le collège, sont un bon moyen de commencer à manipuler des algorithmes. En voici quelques exemples : Exemple 1 : Voici un algorithme en langage naturel : Prendre un nombre, lui ajouter 7, mettre le résultat au carré puis retrancher 3. Annoncer le résultat obtenu. En langage algorithmique : On peut même être plus efficace dans l’écriture en langage algorithmique pour n’avoir que deux lignes : Entrée : Saisir n Traitement : Affecter ሺ݊ ሻʹ െ ͵ à ܣ Sortie : Afficher ܣ Entrée : Saisir ݊ Sortie : Afficher ሺ݊ ሻʹ െ ͵ En langage Graph 75+E : ǫ՜ ܰ ሺܰ ሻʹ െ ͵ ܣ Réalisons maintenant ce programme sur la Graph 75+E Dans le menu principal, sélectionner le menu PROGRAMME : ag. Créer un nouveau programme e. Donner un nom au programme, ici par exemple CALCUL. Ensuite accéder à [PRGM] :Lo. Puis sélectionner le point d’interrogation : r. Enfin, terminer le programme. Pour l’exécuter, sortir de l’éditeur de programme en appuyant deux fois sur d. Sélectionner ensuite l’onglet {EXE}: q. 4 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Il ne reste plus qu’à entrer une valeur, par exemple 3, et appuyer sur l pour que la calculatrice donne le résultat, 97 dans l’exemple. Exemple 2 : Moyenne arithmétique Langage naturel : On donne trois nombres. Calculer la somme de ces trois nombres, diviser cette somme par 3 et annoncer le résultat obtenu. Langage Graph 75+E : Langage algorithmique : ǫ ՜ ܣ Entrée : Saisir ܽǡ ܾǡ ܿ Traitement : Affecter Sortie : ܾܽܿ ͵ ǫ ՜ ܤ ǫ՜ ܥ àܯ ܣܤܥ ՜ܯ ͵ ܯ Afficher ܯ Programmons-le sur la Graph 75+E : Dans le menu PROGRAMME, créer un nouveau programme (e) et lui donner un nom, ici par exemple MOYENNE. Ensuite taper le programme. Rappel : le point d’interrogation est dans [PRGM] : Lo puis r. Il ne reste plus qu’à l’exécuter : appuyer deux fois sur d puis sur q. Le tester avec trois valeurs 10, 11 et 15. Pour la suite du manuel, nous nous concentrerons sur les langages algorithmiques et de programmation. 5 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E II. AFFECTATION Nous avons pu constater, au travers des deux exemples précédents, qu'une des actions de base d'un algorithme est l'affectation. Affecter consiste à attribuer une valeur (très souvent numérique) à une variable (généralement une lettre). - ܣprend la valeur ʹ - ܤprend la valeur െ͵ Exemple 1 : - Affecter ܤà ܣ Qu'affiche l'algorithme suivant ? - Affecter ʹ ܣà ܤ - Afficher ܣet ܤ Pour afficher ܣpuis ܤ, nous allons utiliser la commande « Affichage » symbolisée par un triangle noir : W. Il se trouve dans [PRGM] :Lo puis y. Exemple 2 : Inversion d’une variable Ecrire un algorithme qui "inverse" les valeurs de ࢄ et de ࢅ, c’est-à-dire que si on saisit pour ࢄ et pour ࢅ l'algorithme affiche au final pour ࢄ et pour ࢅ. Le premier réflexe est d’affecter ܺ à ܻ puis ܻ à ܺ. Mais cela ne fonctionne pas car, au final, l’algorithme afficherait deux fois la valeur entrée dans ܺ, la valeur entrée dans ܻ étant « écrasée » par l’affectation de ܺ dans ܻ. Il faut donc utiliser une troisième variable dite « de transfert » pour stocker la valeur de la variable ܻ au tout début de l’algorithme. Entrée : Saisir ܺ et ܻ Traitement : Affecter ܻ à ܼ Affecter ܺ à ܻ Affecter ܼ à ܺ Sortie : Sur une Graph 75+E cela donne : 6 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Afficher ܺ et ܻ III. STRUCTURE CONDITIONNELLE Comme nous l’avons déjà vu, un algorithme permet d’exécuter une liste d’instructions les unes à la suite des autres. Mais on peut aussi demander à l’algorithme de n’exécuter des instructions que si une certaine condition est remplie. C’est la structure conditionnelle « Si… Alors… Sinon… » qui permet de remplir cette fonction. Exemple 1 : Un magasin de photos propose le développement au prix de 0,16 € l’unité. Pour une commande d’au moins 75 photos, le prix passe à 0,12 € l’unité. Ecrire un algorithme qui, lorsqu'on entre le nombre de photos à développer, nous donne le prix à payer pour la commande. Entrée : Nous stockons dans ܰ le nombre de photos commandées. Saisir ܰ Traitement : Si ܰ ͷ Sortie : Alors Afficher ܰ ൈ Ͳǡͳʹ Sortie : Sinon Afficher ܰ ൈ Ͳǡͳ FinSi En langage Graph 75+E : - le "Si" se traduit par "If" ?՜ ܰ If ܰ ͷ - "Alors" par "Then" Then ܰ ൈ ͲǤͳʹ - "Sinon" par "Else" Else ܰ ൈ ͲǤͳ - "FinSi" par "IfEnd". IfEnd Les commandes If, Then, Else et IfEnd sont dans [PRGM] (Lo) puis dans l’onglet {COM} (q). Le symbole "" ainsi que toutes les autres relations d'ordre se trouvent dans l'onglet {REL} : dans [PRGM] faire défiler à l’aide de l’onglet { } (u) puis sélectionner {REL} (e) Sur une Graph 75+E cela donne : 125 photos coûtent 15€. 36 photos coûtent 5,76€. 7 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 2 : L'Indice de Masse Corporel (IMC) est un indicateur (pas forcément toujours fiable) permettant de voir si une personne est en surpoids, en état de maigreur… L'IMC est donné par la formule ࡵൌ ࡼࢊ࢙ሺࢋࢍሻ ࢚ࢇࢋ¸ሺࢋ°࢚࢘ࢋሻ . Si l'IMC est inférieur strictement à 18,5, la personne est considérée en état de maigreur. S’il est strictement supérieur à 25, la personne est considérée en surpoids. Sinon on considère que la corpulence est "normale". Ecrire un algorithme qui, lorsqu’on entre le poids et la taille d’une personne, affiche « surpoids », « normal » ou « maigreur » selon la valeur de son IMC. On stocke dans ܲ le poids de la personne, dans ܶsa taille et dans ܫla valeur de son IMC. La particularité ici est qu'il faut imbriquer l'une dans l'autre deux structures conditionnelles : En langage Graph 75+E cela donne : ?՜ ܲ Entrée : Saisir ܲ et ܶ ?՜ ܶ ܲ Traitement : Affecter ܶ; à ܫ ܲ ՜ܫ ܶ² Si ܫ൏ ͳͺǡͷ Sortie : Alors Afficher « MAIGREUR » If ܫ൏ ͳͺǡͷ Sinon Si ܫ ʹͷ Then "MAIGREUR" Sortie : Alors Afficher « SURPOIDS » Sortie : Sinon Afficher « NORMALE » Else If ܫ ʹͷ Then "SURPOIDS" FinSi Else "NORMALE" FinSi IfEnd IfEnd Ci-contre, l'algorithme programmé sur la Graph 75+E. Le capitaine de l'équipe de France de rugby, Thierry Dusautoir, mesure 1,88m pour 100 kg. Dans quelle catégorie serait-il ? N'avais-je pas dit que l'IMC n'était pas toujours fiable ? 8 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E IV. BOUCLES Une boucle permet de répéter une instruction (ou une liste d'instructions) plusieurs fois. Il y a principalement deux types de boucle : x x Les boucles pour répéter une instruction un certain nombre de fois, il s'agit des boucles « Pour ». Les boucles pour répéter une instruction jusqu'à une condition d'arrêt, il s'agit des boucles « Tant que ». Le passage dans une boucle est appelé itération. 1. Boucles Pour Les boucles « Pour » permettent de répéter une instruction un nombre donné de fois. Elles se caractérisent par le fait que l'on connaît à l'avance le nombre d'itérations que l'on va devoir effectuer. Exemple 1: Traitement : Pour allant de 0 à 10 Afficher ݅ Sortie : Fin Pour Cet algorithme affiche successivement les nombres 0 ; 1 ; … ; 10. On effectue donc 11 itérations. En langage Graph 75+E, cela donne : For 0՜ ܫTo 10 ܫ Next Les commandes For, To et Next se trouvent dans [PRGM] (Lo) puis dans l'onglet {COM} (q). Il suffit ensuite de faire défiler le menu à l’aide de l’onglet { } (u). Ne reste plus qu'à l'exécuter. Appuyer à chaque fois sur l pour avoir la valeur suivante. 9 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 2: Entrée : Saisir ݇ Déterminer la valeur de sortie Traitement : Pour allant de ͳ à ͳͲ Affecter ݇ ݅ െ ʹ à ݇ de l'algorithme ci-contre. Fin Pour Sortie : Afficher ݇ Programmer l'algorithme sur la Graph 75+E : Exécuter le programme en prenant 7 comme valeur. La valeur de sortie est 42 lorsqu'on entre 7. Exemple 3 : On place un capital de 10 000 € au taux de 4 % annuel. Ecrire un algorithme donnant la valeur du capital au bout de ࡺ années, la valeur de ࡺ étant donnée. Utiliser cet algorithme pour déterminer la valeur du capital au bout de 10 ans puis de 20 ans. On utilise ici une boucle « Pour » avec ݅allant de 1 à ܰ. La variable ܥstocke les différentes valeurs du capital, il faut donc l'initialiser à 10 000. Augmenter de 4 % revient à multiplier par 1,04. Saisir ܰ Entrée : Initialisation : ܥprend la valeur 10 000 Traitement : Pour i allant de 1 à ܰ Affecter Cൈ ͳǡͲͶ à C Fin Pour Sortie : Afficher ܥ Programmer l'algorithme sur la Graph 75+E : Exécuter le programme en entrant les valeurs 10 puis 20. Donc au bout de dix ans le capital est de 14 802,44 € et au bout de vingt ans, il a plus que doublé pour atteindre 21 911,23 € (sommes arrondies au centime). 10 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E 2. Boucles Tant que Les boucles « Tant que » permettent d’effectuer des itérations tant qu’une certaine condition est vérifiée. On ne connait pas le nombre d’itérations à effectuer, mais à chaque itération, on vérifie si la condition est vraie ou fausse. Dès que cette condition est fausse, on sort de la boucle. Il est souvent important d'intégrer un "compteur" dans l'algorithme afin de dénombrer le nombre d'itérations effectuées. Exemple 1 : On fait la somme des entiers consécutifs à partir de 1, combien en faut-il pour dépasser 10 000? Ecrire un algorithme pour résoudre ce problème. Commençons en langage algorithmique. On stocke la somme dans la variable ܵ. A chaque itération il faut lui ajouter le compteur, que l'on stocke dans la variable ݅et que l'on incrémente de 1 au fur et à mesure. On commence par initialiser ݅et ܵ à 0. Initialisation : ݅prend la valeur 0 ܵ prend la valeur 0 Traitement : Tant que ܵ ൏ ͳͲͲͲͲ ݅ prend la valeur ݅ ͳ ܵprend la valeur ܵ ݅ Fin Tant que Sortie : Afficher ݅ Sur la Graph 75+E, cela donne : En exécutant le programme on obtient 141. Il faut donc faire la somme des 141 premiers entiers consécutifs pour dépasser 10 000. 11 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 2 : Paul souhaite acheter une voiture coûtant 20 000 €. Pour cela il sollicite un prêt à sa banque pour cette somme au taux mensuel de 0,4 %. Il ne peut rembourser plus de 300 € par mois. Déterminer la durée du prêt. Dans l’algorithme, ܴ est la variable comptabilisant le montant restant. Pour passer d'une année à l'autre il faut donc affecter à ܴl'expression ܴ ൈ ͳǡͲͲͶ െ ͵ͲͲpuisque l'on doit ajouter les intérêts (0,4%) et retrancher la mensualité payée par Paul c’est-à-dire 300 euros. Au départ le montant restant dû est de 20 000 €, donc on initialise la variable ܴ à 20 000. La variable ݅est notre compteur. Elle comptabilise le nombre de mensualités déjà payées. Au départ, elle vaut donc 0. Initialisation : ܴprend la valeur 20 000 ݅prend la valeur 0 Traitement : Tant que ܴ Ͳ Affecter ܴ ൈ ͳǡͲͲͶ െ ͵ͲͲ à ܴ Affecter ݅ ͳà ݅ Fin Tant que Sortie : Afficher ݅ Sur la Graph 75+E, cela donne : En exécutant le programme on obtient : Il faudrait donc 78 mois à Paul pour rembourser son prêt. 12 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 3 : Pour terminer ce paragraphe, réalisons un jeu extrêmement simple : la calculatrice va choisir un nombre au hasard entre 1 et 100, à nous de le retrouver avec pour seules indications "plus haut" et "plus bas" le tout en comptabilisant le nombre d'essais. A la fin le programme affichera le nombre d'essais. Pour réaliser ce programme, on commence par stocker la valeur choisie au hasard par la calculatrice dans la variable ܰ. ܲ représente la valeur choisie par le joueur. Le jeu ne s'arrête donc qu'une fois que ܲ est égal à ܰǤ Enfin la variable ݅comptabilise le nombre d'essais. Elle est initialisée à 1. Il y a une entrée pour débuter le jeu et une entrée dans la boucle « Tant que » qui est utilisée chaque fois que le joueur retente sa chance. Initialisation : ݅prend la valeur 1 ܰprend une valeur au hasard entre 1 et 100 Entrée : Saisir ܲ Traitement : Tant que ܲ ് ܰ Si ܲ ܰ Alors Afficher "Plus bas" Sinon Afficher "Plus haut" Fin Si Entrée : Saisir ܲ Affecter ݅ ͳ à ݅ Fin Tant que Sortie : Afficher ݅ Maintenant programmons cet algorithme avec la Graph 75+E. Pour choisir un nombre au hasard il faut utiliser la commande RanInt#. Cette commande se trouve dans OPTION (i). Faire défiler (u), choisir l'onglet {PROB} (e), sélectionner {RAND} (r) puis {Int} (e). On peut aussi aller chercher cette commande dans [CATALOG] (L4). Voici le programme sur la Graph 75+E : On peut ensuite tester notre jeu. 13 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E V. Vers un peu plus de complexité Nous avons vu, dans les quatre premiers paragraphes, les actions de base des algorithmes notamment à l'aide d'exemples d'algorithmes globalement assez simples. Dans cette partie nous nous intéresserons à des algorithmes un peu plus complexes, ce qui nous permettra de voir au passage quelques nouvelles actions, commandes et fonctionnalités. Exemple 1 : Année bissextile Une année bissextile est une année dont le numéro est divisible par 4 mais pas par 100. Ecrire un algorithme permettant de déterminer si une année de numéro donné est bissextile ou non. Ici la complexité n'est en rien située dans le langage algorithmique qui est somme toute assez basique : Entrée : Saisir ܰ Traitement : Si ܰ est divisible par 4 et pas par 100 Sortie : Alors Afficher "Bissextile" Sortie : Sinon Afficher "Non bissextile" Fin Si Le problème est que la calculatrice ne sait pas reconnaître directement si un nombre est divisible par 4 ou par 100. Nous allons donc repartir de la définition de la divisibilité pour résoudre ce problème. Un entier est divisible par 4 si son quotient par 4 est un entier. Pour tester si le quotient du nombre donné par 4 est un entier nous utiliserons la fonction partie entière. La fonction partie entière est la fonction mathématique E qui, à tout réel, associe le premier entier inférieur ou égal à celui-ci. Exemples : ܧሺʹǡ͵ሻ ൌ ʹ ܧሺͲǡͷሻ ൌ Ͳ ܧሺെͲǡͻͻሻ ൌ െͳ. La fonction partie entière se traduit en langage calculatrice par Intg. Cette commande se trouve dans OPTION (i). Faire défiler (u), puis sélectionner l'onglet {NUM} (r). L'algorithme va afficher de toute façon "BISSEXTILE" et il affichera avant "NON" si le numéro de l'année n'est pas divisible par 4 ou s’il est divisible par 100. 14 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Algorithme en langage Graph 75+E : Ce qui donne sur la calculatrice : ?՜ ܰ If Intg(ܰȀͶ)് ܰȀͶ Then "NON" Else If Intg(ܰȀͳͲͲ)ൌ ܰȀͳͲͲ Then "NON" IfEnd IfEnd "BISSEXTILE" Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Exemple 2 : Suite de Fibonacci Extrêmement connue la suite de Fibonacci a un fonctionnement très simple. Pour calculer le terme suivant de la suite, il suffit d'ajouter les deux précédents (les deux premiers termes sont égaux à 1). Le début de la suite est donc 1 ; 1 ; 2 ; 3 ; 5 ; 8 ; 13 ; 21 … Ecrire un algorithme qui donne le ࡺ-ième terme de la suite de Fibonnacci. Il faut, comme pour l'algorithme d'inversion de variables (vu précédemment), utiliser une variable de transfert. Nous stockons dans ܸle terme précédent à celui que l'on va calculer et dans ܷle terme encore précédent, enfin ܹ est la variable de transfert. Ce qui donne sur la Graph 75+E : Entrée : Saisir ܰ Initialisation : ܷprend la valeur 1 ܸ prend la valeur 1 Traitement : Pour ݅allant de 1 à N Affecter ܷ ܸà ܹ Affecter ܸ à ܷ Affecter ܹ à ܸ Fin Pour Sortie : Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Afficher ܸ On peut ainsi calculer le 40ème terme de la suite de Fibonacci : 15 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 3 : Méthode de Monte-Carlo Soit ࢍ une fonction positive sur un intervalle ሾࢇǢ ࢈ሿ et ࢍ sa courbe représentative. Pour calculer ࢈ l’intégrale ࡵ ൌ ࢍ ࢇሺ࢞ሻࢊ࢞, il est parfois difficile voire impossible de déterminer une primitive de la fonction ࢍ et donc de calculer ࡵ. On cherche alors à calculer une valeur approchée. On considère le rectangle ABCD où A, B, C et D ont pour coordonnées respectives ሺࢇǢ ሻ, ሺ࢈Ǣ ሻ, ሺ࢈Ǣ ሻ et ሺࢇǢ ሻ dans un repère orthonormé, étant le maximum de ࢍ sur ሾࢇǢ ࢈ሿ. La méthode de Monte-Carlo consiste à choisir successivement et au hasard points dans le rectangle ABCD, étant un entier naturel non nul. Pour chaque point, on contrôle s’il est situé ou non sous la courbe ࢍ. A la fin de l’expérience aléatoire, on a ainsi comptabilisé le nombre de points situés sous la courbe ࢍ parmi les points choisis au hasard dans le rectangle ABCD. On appelle ࢌ la fréquence associée à cet effectif. Construire un algorithme qui affiche une valeur approchée de l’intégrale ࡵ pour points testés, la valeur de étant donnée. Entrée : Saisir ݊ Initialisation : ܿ prend la valeur 0 Traitement : Pour ݅ allant de 1 à ݊ ݔprend la valeur ܽ ሺܾ െ ܽሻ ൈ ±Ͳ݁ͳݐ ݕprend la valeur ݉ ൈ ±Ͳ݁ͳݐ Si ݕest inférieur ou égal à ݃ሺݔሻ Alors ܿ prend la valeur ܿ ͳ Fin Si Fin Pour Sortie : ܿ Afficher ݊ ൈ ݉ሺܾ െ ܽሻ La variable ܿ comptabilise le nombre de points qui sont situés sous la courbe ݃ܥ. ͳ Nous allons utiliser cet algorithme pour estimer la valeur de Ͳξͳ െ ݔ݀¸ݔ. On peut démontrer que le maximum de la fonction ݃ǣ ݔ՜ ξͳ െ ¸ݔsur ሾͲǢ ͳሿ est 1. Donc la valeur de ݉ est 1. Celle de ܽ est 0 et celle de ܾ est 1. Réalisons cet algorithme sur la Graph 75+E. Pour choisir un nombre au hasard entre 0 et 1 nous allons utiliser la commande Ran#. Cette commande se trouve dans OPTION (i). Faire défiler (u), choisir l'onglet {PROB} (e), sélectionner {RAND} (r) puis Ran# (q). On peut aussi aller chercher cette commande dans [CATALOG] (L4). On peut alors estimer la valeur de cette intégrale, plus la valeur de ܰ sera grande, plus l’estimation sera bonne. Nous choisirons ܰ=10 000 (le calcul peut être un peu long). Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources 16 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E On peut vérifier que notre approximation est bonne en calculant cette intégrale directement avec la calculatrice : Dans le menu RUN-MAT, sélectionner l’onglet {MATH} (r), faire défiler (u) et choisir l’onglet { } (q). Il suffit maintenant d’entrer les bornes et l’expression algébrique de ߨ la fonction. On peut ainsi vérifier que la valeur exacte est . Ͷ On peut aussi demander à chaque élève de déterminer uniquement la proportion de points situés sous la courbe et regrouper ensuite les résultats de la classe. Pour cela, au lieu de calculer la fréquence, on place les points dans le rectangle ABCD. En rouge ceux qui sont situés sous la courbe ݃ܥet en bleu ceux qui sont dessus. ͳ Dans notre exemple où l’on s'intéresse à Ͳξͳ െ ݔ݀¸ݔ, l'algorithme donne donc : Saisir ݊ Entrée : Initialisation : Changer la fenêtre graphique : ܺ݉݅݊ ൌ ͲǢ ܺ݉ܽ ݔൌ ͳ ; ܺ݃ ݀ܽݎൌ Ͳǡͳ ܻ݉݅݊ ൌ Ͳ; ܻ݉ܽ ݔൌ ͳǢܻ݃ ݀ܽݎൌ Ͳǡͳ Traitement : Pour ݅ allant de 1 à ݊ ݔprend la valeur d’un nombre aléatoire entre 0 et 1 ݕprend la valeur d’un nombre aléatoire entre 0 et 1 Si ݕest inférieur ou égal à ξͳ െ ¸ݔ Sortie : Alors placer en rouge le point de coordonnées ሺݔǢ ݕሻ Sortie : Sinon placer en bleu le point de coordonnées ሺݔǢ ݕሻ Fin Si Fin Pour Nous allons utiliser une fx-CP400+E pour réaliser le programme correspondant à l'algorithme. Quelques changements sont à effectuer par rapport au langage des Graph 35+E et Graph 75+E. "Saisir" se traduit Input. Aller dans l’onglet {E/S} et sélectionner Input. La commande pour changer la fenêtre graphique se nomme ViewWindow. Aller dans l’onglet {Divers}, sélectionner Graphe&Table(1) puis ViewWindow. Pour placer un point, la commande s'appelle PlotOn. Aller dans l’onglet {E/S}, sélectionner Dessin puis Trc et enfin PlotOn. Pour choisir la couleur, aller dans l’onglet {E/S}, sélectionner Coul. et enfin choisir la couleur voulue. 17 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Voilà ce que donne l'algorithme lorsque l'on entre ܰ ൌ ͷͲ (là encore cela prend un peu de temps mais on peut choisir une valeur de ܰ plus petite). On peut aussi représenter graphiquement l’intégrale à l’aide de Monte-Carlo. Par exemple, pour la fonction carrée, on a juste à faire quelques changements dans l’algorithme. On va ouvrir une fenêtre où ݔvarie entre െͳ et ͳ pour pouvoir visualiser l’axe de symétrie de la parabole. Pour obtenir un nombre aléatoire dans cet intervalle on calcule d’abord un nombre aléatoire entre Ͳ et ͳ grâce à la fonction rand(), on multiplie par ʹ et on retranche ͳ. Pour N=5 000, on obtient : 18 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 4 : Suite de Syracuse On considère la suite ሺ࢛ ) définie par son premier terme ࢛ , un entier naturel, et par la relation de récurrence : ࢛ ࢛ ൌ si ࢛ est pair ࢛ ൌ ࢛ sinon Il a été conjecturé (mais pas encore démontré à ce jour) que la suite de Syracuse ayant comme premier terme n'importe quel entier strictement positif, atteint, au bout d’un certain nombre d’itérations, 1. Le temps de vol de la suite est le rang du premier terme de la suite égal à 1. Ecrire un algorithme donnant le temps de vol lorsque la valeur du premier terme est donnée. Entrée : Saisir ܷ Initialisation : ܰ prend la valeur 0 Traitement : Tant que ܷ ് ͳ Pour tester la parité nous utilisons la même méthode que pour l'algorithme sur l'année bissextile : Affecter ܰ ͳ à ܰ Si ܷ est pair Alors Affecter on teste si ܷ ʹ àܷ Sinon Affecter ͵ܷ ͳ à ܷ ܷ ʹ est un entier ou non à l'aide de la fonction "partie entière" (Commande Intg). Fin Si Fin Tant que Sortie : Afficher ܰ Sur la Graph 75+E cela donne : Regardons le temps de vol lorsque Ͳݑൌ ͳͻ : Le temps de vol de 169 est de 49. Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources 19 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 5 : Algorithme de Kaprekar L’algorithme de Kaprekar consiste à itérer le processus suivant : Soit un nombre à trois chiffres distincts. Calculer la différence du nombre constitué des 3 chiffres rangés dans l’ordre décroissant et du nombre composé des trois chiffres rangés dans l’ordre croissant. Kaprekar a démontré que cet algorithme aboutissait toujours au même nombre. Vérifier cette conclusion en écrivant un programme réalisant l’algorithme. En déduire le nombre auquel aboutit l’algorithme. Si deux nombres consécutifs obtenus par l'algorithme sont égaux alors l'algorithme répétera indéfiniment ce même nombre. Nous utilisons donc une boucle « Tant que » qui s'arrête dès que deux nombres obtenus consécutivement par l'algorithme sont égaux. On stocke dans ( ܩpour Grand) le plus grand des trois chiffres et dans ܲ (pour Petit) le plus petit des trois chiffres. Inutile de s'occuper du chiffre du milieu puisqu'en faisant la différence, il s'annule de toute façon. La variable ܦsert à stocker le résultat de l'algorithme pour tester si deux résultats consécutifs sont égaux. On l'initialise donc à 0. Voilà ce que donne l'algorithme en langage algorithmique : Entrée : Saisir ܰ Initialisation : ܦprend la valeur 0 Tant que ܰ ് ܦ Affecter ܰ à ܦ Affecter le plus grand des trois chiffres de ܰ à ܩ Affecter le plus petit des trois chiffres de ܰ à ܲ Affecter à ܰ le nombre ܩൈ ͳͲͲ ܲ െ ܲ ൈ ͳͲͲ െ ܩ Fin Tant que Sortie : Afficher ܰ Pour le langage calculatrice, le problème est "d'extraire" les chiffres du nombre N pour ensuite utiliser les commandes Max et Min. Celles-ci se trouvent dans OPTION (i), sélectionner l'onglet {List} (q) puis faire défiler (u). Pour extraire les chiffres nous allons diviser le nombre N par 100 puis par 10 en prenant à chaque fois la partie entière (commande Intg) et en retranchant les chiffres "extraits" petit à petit. C'est l'objet des lignes 5 à 8 du programme ci-contre: NB : les commandes Min et Max donnent le minimum et le maximum d'une liste, c'est pourquoi on met A, B, C entre accolades. Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources 20 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E En l'exécutant avec n'importe quelle valeur on obtient : 495. L'algorithme de Kaprekar converge vers 495. Exemple 6 : Nombres parfaits Un nombre parfait est un nombre ݊ dont la somme de tous les diviseurs est égale à ʹ݊ǡ c’est-à-dire dont la somme de tous les diviseurs propres (diviseur distinct du nombre luimême) est égale à ݊. Ecrire un algorithme qui détermine si un nombre donné est un nombre parfait ou non, puis modifier cet algorithme pour qu'il affiche la liste de tous les nombres parfaits inférieurs ou égaux à une valeur donnée. Entrée : Saisir ݊ Initialisation : ݏprend la valeur 0 Traitement : Pour ݅allant de 1 à ݊ ܧቀʹ ቁ Si ݊ est divisible par ݅ Alors Affecter ݏ ݅ à ݏ Fin Si propre ne peut être plus grand que la moitié du nombre). La variable ݏstocke la somme des diviseurs. Une fois testés tous les nombres de Fin Pour ݊ 1 à ܧቀʹ ቁ, il ne reste plus qu'à vérifier Si ݏൌ ݊ Alors Sortie : On teste les diviseurs jusqu'à la ݊ partie entière de (car un diviseur ʹ Afficher "Parfait" si la somme des diviseurs est égale au nombre, c’est-à-dire si ݏൌ ݊ . Si c'est le cas, le nombre est parfait. Sinon Sortie : Afficher "Non parfait" Fin Si Voici l'algorithme programmé sur la Graph 35+E. La fonction partie entière se traduit par Int . Cette commande se trouve dans OPTION (i), faire défiler (u) puis sélectionner l'onglet {NUM} (r). 21 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E On peut modifier l'algorithme précédent pour qu'il affiche tous les nombres parfaits inférieurs ou égaux à une valeur donnée ݇. Il suffit juste d'inclure le programme précédent dans une boucle « Pour » (Pour ݊ allant de 1 à ݇) et d'afficher uniquement les valeurs pour lesquelles la somme des diviseurs propres est égale au nombre testé. Cela donne : Entrée : Saisir ݇ Initialisation : ݏprend la valeur 0 Traitement : Pour ݊ allant de 1 à ݇ ݏprend la valeur 0 Pour ݅allant de 1 à ݊ Si ݊ est divisible à par ݅ Alors Affecter ݏ ݅à ݏ Fin Si Fin Pour Si ݏൌ ݊ Alors Afficher ݊ Sortie : Fin Si Fin Pour Voici l'algorithme programmé sur la Graph 35+E : Et les nombres parfaits inférieurs ou égaux à 500 sont : Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources 22 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 7 : Algorithme de tri Ecrire un algorithme permettant de trier, dans l'ordre croissant, une liste donnée dont on aura précisé la longueur : . La méthode de tri utilisée sera celle du tri par sélection : on commence par chercher le plus grand élément de la liste que l'on met en dernier, puis on recommence l'opération avec les െ premiers termes… Cette méthode de tri n'est pas, loin s'en faut, la plus efficace mais c'est sûrement la plus simple. La liste est appelée Liste 1, on note ݊ sa longueur. Après avoir demandé la longueur de la liste et ses éléments (un à un), pour ݅ allant de 1 à ݊, on détermine le ݅-ème plus grand terme de la liste et on le met à sa place (c’est-à-dire à la ݊ െ ݅-ème). Pour cela, on introduit une variable ݇ qui contient le rang de la dernière position non encore classée. Au départ ݇ vaut donc ݊ et on lui retranche un à chaque itération. La variable ܽ stocke la plus grande valeur dans la liste (jusqu'au ݇-ème terme) et est son rang, au départ ܽ est donc égal à la première valeur de la liste et ൌ ͳ. Ensuite, pour chaque terme, on regarde s’il est plus grand ou non que ܽ, si c'est le cas on remplace ܽ par cette valeur et par le rang du terme. A la fin de la boucle il suffit de remplacer le -ème terme de la liste par le ݇-ème, et le ݇-ème terme par la valeur de ܽǤ Initialisation : Initialiser Liste 1 comme une Liste Entrée : Saisir ݊ Pour ݅ allant de 1 à ݊ Entrée : Saisir le ݅-ème terme de la liste 1 Fin Pour Initialisation : Affecter ݊ à ݇ Traitement : Pour ݅ allant de 1 à ݊ Affecter le 1er terme de la Liste 1 à ܽ Affecter 1 à Pour ݆allant de 2 à ݇ Si ܽ est strictement plus petit que le ݆-ème terme de la Liste 1 Alors Affecter le ݆-ème terme de la Liste 1 à ܽ Affecter ݆à Fin Si Fin Pour Affecter le ݇-ème élément de la Liste 1 au -ème Affecter ܽ au ݇-ème élément de la liste. Affecter ݇-1 à ݇ Fin Pour Sortie : 23 Afficher Liste 1 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Ci-contre, l’algorithme programmé sur la fx-CP400+E. Initialiser une liste consiste à affecter {} à ͳܮ. Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Exemple 8 : Convertisseur système binaire Le système binaire est un système de numération en base 2. Celui utilisé par les ordinateurs est composé uniquement de 0 et 1 : ce sont les fameux bits (de l'anglais binary digit. Les processeurs des ordinateurs ne reconnaissent que ces deux nombres. Comment traduire un nombre en base décimale dans le langage binaire ? Rappelons brièvement le principe de la numérotation binaire. Le nombre binaire 11011 code le nombre 27 car 11011՜ ൈ ൈ ൈ ൈ ൈ ൌ ૠ. Dans l'autre sens si l'on veut par exemple coder en binaire le nombre 57, on cherche la plus grande puissance de 2 contenue dans le nombre, ici c'est 32 ( ሻ. Ensuite on fait la division euclidienne successive du nombre par ǡ ǡ ǥ ǡ (en retranchant le diviseur lorsque le dividende n'est pas nul. Le nombre binaire est composé des différents dividendes : ૠ ൌ ൈ ൈ ൈ ൈ ൈ ൈ donc en binaire le nombre donne 111001. Construire un algorithme traduisant un nombre du système décimal au système binaire. Tout d'abord, il faut commencer par initialiser à 0 la variable ܤqui stockera le nombre en binaire. Ensuite, il faut déterminer la plus grande puissance ݅ de 2 contenue dans le nombre. On initialise donc ݅ à 0, on demande la valeur du nombre puis on augmente la valeur de ݅ jusqu'à ce que la division de ܰ par ʹ݅ͳ donne un résultat plus petit que 1. Pour construire le nombre en binaire nous allons utiliser ܧ, la fonction partie entière. 24 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Initialisation : ܤprend la valeur 0 ݅ prend la valeur 0 Entrée : Saisir ܰ Traitement : Tant que la division de ܰ par ʹ݅ͳ est supérieure ou égale à 1 Affecter ݅+1 à ݅ Fin Tant que Pour ݇ allant de 0 à ݅ ܰ Affecter ܧቀʹ݅െ݇ ቁ ൈ ͳͲ݅െ݇ ܤà ܤ ܰ Affecter ܰ െ ܧቀʹ݅െ݇ ቁ ൈ ʹ݅െ݇ àܰ Fin Pour Sortie : Afficher ܤ Voici l'algorithme programmé sur la Graph 35+E : On peut le tester avec par exemple 57 et 654 : Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Exemple 9 : Marche aléatoire "A consommer avec modération" Bob a un peu trop célébré son augmentation de salaire, du coup il n'arrive plus à marcher droit. A chaque pas il avance d'un mètre mais se décale aussi d'un mètre vers la gauche ou d'un mètre vers la droite (à égale probabilité. Bob arrive sur un pont d'une largeur de 6 mètres et d'une longueur de 15 mètres. Au départ il est au milieu du pont. Ecrire un algorithme simulant le passage sur le pont (deux résultats possibles : Bob tombe à l'eau ou arrive sain et sauf au bout du pont puis un autre permettant d'illustrer le trajet. Conjecturer ensuite la probabilité qu'a Bob de traverser sain et sauf le pont. 25 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E On pose un repère orthonormé dont l'origine est la position de Bob au départ. Soit ܺ l'abscisse de la position de Bob et ܻ son ordonnée. Bob est à l'eau si ܻ ͵ ou si ܻ ൏ െ͵ c’est-à-dire si ȁܻȁ ͵. Il est sain et sauf si ܺ atteint 15 sans que ȁܻȁ ͵. En langage algorithmique cela donne donc : Initialisation : ܺ prend la valeur 0 ܻ prend la valeur 0 Traitement : Tant que ܺ ൏ ͳͷ et ȁܻȁ ൏ Ͷ Affecter ܺ ͳ à ܺ Affecter à ܰ un nombre entier compris entre 0 et 1 Affecter ܻ ሺെͳሻܰ ܻ Fin Tant que Si |ܻȁ ൏ Ͷ Sortie : Alors Afficher "SAIN ET SAUF" Sortie : Sinon Afficher "A L'EAU" Fin Si Voilà ce que donne le programme sur la Graph 35+E : Pour la programmation sur la Graph 35+E, deux nouveautés : - - la commande "et", qui se traduit par "And" et se trouve dans OPTION (i) : faire défiler deux fois (u puis u) et sélectionner l'onglet {LOGIC} (r). la commande "Abs" pour la valeur absolue se trouve dans OPTION (i) puis dans l'onglet {COMPLEX} (e). Afin de conjecturer la probabilité qu'a Bob de traverser sain et sauf le pont, modifier le précédent programme et l'insérer globalement dans une boucle Pour qui effectue un grand nombre d'itérations (par exemple 10 000). Intégrer aussi un compteur (variable C) qui comptabilise le nombre de fois où Bob est arrivé sain et sauf au bout du pont (commencer donc par l'initialiser à 0). Il ne reste plus qu'à afficher la fréquence de ܥ fois où Bob a franchi le pont (ͳͲͲͲͲ ). Cela donne ainsi : 26 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Faire tourner le programme : D'après la loi des grands nombres ce résultat est une bonne approximation de la probabilité que Bob arrive sain et sauf au bout du pont. Pour visualiser le chemin effectué, reprendre le premier programme et le modifier pour placer les points successifs correspondant à la position de Bob. Pour ce faire, utiliser la commande PlotOn (déjà utilisée dans un exemple précédent). Tracer les limites du pont grâce à la commande "Y=". Cette commande se trouve dans l’onglet {SKTCH} (L puis r) : sélectionner l'onglet {GRPH} (y) puis {Y=} (q). Il faudra aussi modifier la fenêtre graphique à l'aide de la commande ViewWindow. Voici le programme en question : Voici un exemple de trajet : Voici l’algorithme correspondant avec la fx-CP400+E. Pour accéder aux commandes DrawShade et Draw aller dans l’onglet {E/S} puis sélectionner Tracé Un exemple de trajet : Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources 27 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 10 : La fractale du vieux chien (D'après D. Hidra) Trois prisonniers, enchaînés en des points éloignés de la cour d'un pénitencier, préparent un plan pour s'évader. A mi-chemin des deux premiers se trouve le vieux chien de garde, tenant dans sa gueule le trousseau de clés. Chacun des prisonniers agite alors un bel os pour attirer le chien, qui choisit au hasard de se diriger lentement vers l'un d'entre eux. Mais, arrivé à mi-chemin, fatigué, le vieux chien se couche et creuse un trou. Les prisonniers agitent alors de plus belle leurs appâts : le chien se réveille et avance à nouveau au hasard vers l'un d'eux. Arrivé à la moitié du chemin il s'arrête encore et fait un autre trou... et ainsi de suite un très grand nombre de fois. Construire et programmer un algorithme qui permet d'obtenir une vue aérienne de la figure obtenue avec les trous progressivement creusés par le chien. Indications : on pourra modéliser la position des prisonniers par le triangle ܥܤܣavec ܣሺͲǢ Ͳሻ, ܤሺͲǡͷǢ ͳሻ, ܥሺͳǢ Ͳሻ et la position initiale du chien par le point ܯmilieu du segment ሾܤܣሿ. On se limitera aux 10 000 premiers trous creusés par le chien. Modélisation du problème par un algorithme en langage naturel : Variables : ܣݔǢ ܣݕǢ ܤݔǢ ܤݕǢ ܥݔǢ ܥݕǢ ܯݔǢ ܯݕréels Ǣ ܿ entiers Initialisation : ܣݔൌ Ͳ; ܣݕൌ Ͳ (le 1¶ prisonnier) ܤݔൌ Ͳǡͷ; ܤݕൌ ͳ (le 2¶ prisonnier) ܥݔൌ ͳ; ܥݕൌ Ͳ (le 3¶ prisonnier) ܯݔൌ Ͳǡʹͷ; ܯݕൌ Ͳǡͷ (le chien au départ) ൌ ͳͲͲͲͲ (le nombre de trous) Traitement/Sortie : Pour ݅ allant de ͳ à ͳͲͲͲͲ ܿ ൌ ±ͲǢ ͳʹ (le choix) Si ܿ ൌ Ͳ alors ൌ sinon Si ܿ ൌ ͳ alors ൌ sinon ൌ ൌle milieu du segment ሾሿ Afficher Fin Pour 28 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple de programmation avec la Graph 75+E : Affichage progressivement obtenu à l'exécution du programme : La figure obtenue en modélisant les trous creusés par le vieux chien est une fractale qui porte le nom de triangle de Sierpinski. Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Programmation avec la fx-CP400+E : Pour ݊ ൌ ͷͲͲ, on obtient : 29 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 11: Suite de Conway revisitée La suite de Conway, vous connaissez ? Dans cette suite dite "audioactive", un terme se détermine en annonçant les chiffres formant le terme précédent. Le premier terme vaut 1. Voici les premiers termes de la suite de Conway : 1 11 (car le terme précédent est composé d'un 1) 21 (car le terme précédent est composé de deux 1) 1211 (car le terme précédent est composé d'un 2 et d'un 1) 111221 Construire un algorithme donnant la liste des ࡼ premiers termes de la suite avec un premier terme ࡺ donné. L'algorithme étant relativement long, nous allons détailler étape par étape la construction d'un terme par rapport au précédent. Pour faire la liste de termes, il suffira d'itérer le processus à l'aide d'une boucle « Pour ». Nommons ܰ le terme précédent. Tout d'abord, il faut extraire les chiffres composant ܰ et les stocker un à un, dans l'ordre, dans une liste que nous nommerons ͳܮ. Pour extraire les chiffres il faut déjà déterminer le nombre de chiffres présents. On divise donc ܰ par ͳͲ ܮjusqu'à ce que l'on obtienne un nombre plus petit strictement que 1. La dernière valeur de ܮutilisée est donc la "Longueur" de ܰ, c’est-à-dire le nombre de chiffres que contient ܰ. En langage algorithmique cette étape donne : Initialisation : ܮprend la valeur 1 ܰ Traitement : Tant que ͳͲ ܮ ͳ Affecter ܮ+1 à ܮ Fin Tant que Ensuite on peut extraire les chiffres un à un en commençant par la gauche, pour cela on prend la partie entière (fonction E) de ܰ ͳͲ ܮെܭ pour ܭallant de 1 à ܮet on retranche ce même nombre multiplié par ͳͲܮെ ܭà ܰ. On les stocke dans la liste ͳܮqu'il faut commencer par initialiser. Cette étape peut s'écrire sous la forme : Initialisation : ͳܮest une liste Traitement : Pour ܭallant de 1 à ܮ ܰ ሻ ͳͲ ܮെܭ Affecter ܧሺ comme ܭ-èmeterme de la liste ͳܮ ܰ Affecter ܰ- ܧቀͳͲ ܮെ ܭቁ ൈ ͳͲܮെ ܭà ܰ Fin Pour 30 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Ensuite, on construit le terme suivant de la suite que nous stockons dans ܰ, variable qui a été réinitialisée à 0 par l'étape précédente (puisqu'on a extrait un à un les chiffres composant le nombre ܰ). Le principe de cette étape (la plus difficile) est le suivant : Pour chaque chiffre, en commençant par celui qui est le plus à droite (donc le ܮെ °݉݁ chiffre du nombre), on détermine si le chiffre suivant est le même. Si c'est le cas on incrémente d'un un compteur ܥet on passe au chiffre suivant. Si ce n'est pas le cas on ajoute à ܰ le nombre ሺͳͲ ܥnotre chiffre) le tout multiplié par ͳͲ ܯ( ܯpermettant de comptabiliser les chiffres que nous avons déjà "entrés" dans ܰ, on l'augmente de 2 à chaque fois que l'on ajoute quelque chose à ܰ). On effectue aussi ce calcul lorsqu'on arrive au dernier chiffre. Pour terminer, il ne reste plus qu'à afficher le résultat obtenu, résultat stocké dans ܰ. Voici cette étape en langage algorithmique : Initialisation : ܥprend la valeur 1 ܯprend la valeur 0 Traitement : Tant que ܮest différent de 0 Si ܮൌ ͳ Alors Affecter ܰ ሺͳͲ ܥ ݇-ème chiffre de ) ͳܮൈ ͳͲ ܯà ܰ Sinon Si ݈݁ܭ-ème et le ܭ-1-ème chiffre de ͳܮsont égaux Alors Affecter ܥ ͳ à ܥ Sinon Affecter ܰ ሺͳͲ ܥ ݇-èmechiffre de ) ͳܮൈ ͳͲ ܯà ܰ Affecter ܯ ʹà ܯ Affecter 1 à ܥ Fin Si Fin Si Affecter ܮ-ͳà ܮ Fin Tant que Sortie : 31 Afficher ܰ Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Pour faire l'algorithme en entier, on associe les trois étapes précédentes que l'on englobe dans une boucle « Pour » (Pour ܬallant de 1 à ܲ-ͳ). On peut tout récapituler ainsi (en regroupant toutes les initialisations ensemble) : Entrée : Saisir ܰ (le premier terme) Saisir ܲ (le nombre de termes à afficher) Traitement : Pour ܬallant de 1 à ܲ-1 Initialisation : ܮprend la valeur 1 ͳܮest une liste ܥprend la valeur 1 ܯprend la valeur 0 Traitement : Tant que ܰ ͳͲ ܮ ͳ Affecter ܮ+1 à ܮ Fin Tant que Pour ܭallant de 1 à ܮ Affecter ܧሺ ܰ ሻ ͳͲ ܮെܭ comme ܭ-ème terme de la liste ͳܮ ܰ ቁൈ ͳͲ ܮെܭ Affecter ܰ െ ܧቀ ͳͲܮെ ܭà ܰ Fin Pour Tant que ܮest différent de 0 Si =ܮ1 Alors Affecter ܰ ሺͳͲ ܥ ݇-èmechiffre de ) ͳܮൈ ͳͲ ܯà ܰ Sinon Si le ܭet le ܭ-1-èmechiffre de ͳܮsont égaux Alors Affecter ܥ+1 à ܥ Sinon Affecter ܰ ሺͳͲ ܥ ݇-èmechiffre de ) ͳܮൈ ͳͲ ܯà ܰ Affecter ܯ+2 à ܯ Affecter 1 à ܥ Fin Si Fin Si Affecter ܮ-1 à ܮ Fin Tant que Sortie : Afficher ܰ Fin Pour 32 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Programmation de l’algorithme sur la fx-CP400+E. Rappel : Initialiser une liste ͳܮconsiste à Affecter {} à ͳܮ. En utilisant ce programme, afficher les cinq premiers termes de la suite de premier terme 1223 : Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Exemple 12 : Jeu de mémoire Programmons maintenant un petit jeu de mémoire. Le principe est simple : la calculatrice va afficher une séquence de touches (parmi haut, bas, gauche, droite) qu'il faudra recomposer à l'identique sur le clavier (dans l'ordre). Au départ la séquence ne comporte qu'une touche et tant que le joueur ne se trompe pas, la séquence augmente d'une touche à chaque fois. Le jeu se termine lorsque le joueur fait une erreur ; à ce moment-là la calculatrice affiche le score, c’est-à-dire le nombre de touches qu'il a réussi à mémoriser. Tout d'abord il faut que le joueur se tienne prêt à mémoriser : Sortie : Afficher "Prêt ?" Pause 33 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Ensuite, commence le jeu proprement dit. Nous stockons la combinaison de touches à mémoriser dans la liste n°1, il faut donc l'initialiser. La variable ܰ stocke le nombre de touches à mémoriser. Il faut l'initialiser au départ à 0 et l'incrémenter de 1 à chaque tour. ܬest la variable qui comptabilise le nombre de touches correctement trouvées par le joueur. Au tout début, elle vaut 0 et à chaque début de tour elle est réinitialisée à 0. Le jeu continue tant que le nombre de touches correctement trouvées est égal au nombre de touches présentées, c’est-à-dire tant que ܬൌ ܰ. Enfin ܫcontient la position, dans la liste 1, de la nouvelle touche à reproduire à chaque tour. Elle vaut 0 au départ. Cette partie de l'algorithme donne : Initialisation : ܫprend la valeur Ͳ ܬprend la valeur Ͳ ܰ prend la valeur Ͳ Initialiser Liste 1 comme une liste Traitement : Tant que ܬൌ ܰ Effacer Affecter ܰ ͳ à ܰ Affecter ܫ ͳ à ܫ AffecterͲ à ܬ Pour poursuivre l'algorithme, on doit choisir au hasard une nouvelle touche à afficher à la suite de la séquence précédemment choisie. On choisit donc au hasard un nombre entre 1 et 4, que l'on stocke dans B. Sur la Graph 35+E, la touche "Gauche" correspond à la valeur 38, "Haut" à 28, "Droite" à 27 et "Bas" à 37. Il faut donc faire correspondre les entiers de 1 à 4 à une de ces valeurs et la stocker en ܫ-ème position dans la Liste 1. Cela donne : Affecter un nombre entier au hasard entre 1 et 4 à ܤ Si ܤൌ ͳalors Affecter 38 en ܫ-ème position de la liste 1 Fin Si Si ܤൌ ʹalors Affecter 28 en ܫ-ème position de la liste 1 Fin Si Si ܤൌ ͵alors Affecter 27 en ܫ-ème position de la liste 1 Fin Si Si ܤൌ Ͷalors Affecter 37 en ܫ-ème position de la liste 1 Fin Si 34 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Ensuite, il faut afficher la séquence de touches complète. A l'aide d'une boucle « Pour », l'algorithme lit une à une les valeurs de la Liste 1 et affiche à chaque fois la touche correspondante puis l'efface (afin que l'on puisse voir la suivante). On a donc : Pour ܶ allant de 1 à ܰ Si le ܶ-ième chiffre de la liste 1 est 38 alors Afficher une flèche vers la gauche Fin Si Si le ܶ-ième chiffre de la liste 1 est 28 alors Afficher une flèche vers le haut Fin Si Si le ܶ-ième chiffre de la liste 1 est 27 alors Afficher une flèche vers la droite Fin Si Si le ܶ-ième chiffre de la liste 1 est 37 alors Afficher une flèche vers le bas Fin Si Effacer Fin Pour La suite concerne le joueur : il doit reproduire la séquence de touches présentées. Pour chaque touche présentée (Pour ܫallant de 1 à ܰ), il doit appuyer sur une touche. La variable ܣest affectée de la valeur de la touche appuyée. A chaque itération, la valeur de ܣest remise à 0 en attendant que le joueur appuie sur la touche suivante (si le joueur ne s'est pas trompé précédemment auquel cas le jeu s'arrête directement grâce à la ligne Si ܫ=ܬ-1). Si la valeur de ܣest la même que la valeur en ܫ-ème position de la liste 1, on incrémente le compteur ܬde 1. Ainsi, si le joueur ne fait pas d'erreur, au final ܬaura la même valeur que ܰ (le nombre de touches présentées). Voici cette partie de l'algorithme : Pour ܫallant de 1 à ܰ Affecter 0 à ܣ Si ܫ=ܬ-1 Alors Tant que =ܣ0 Affecter la valeur de la touche appuyée à ܣ Si ܣest égal à laܫ-ème valeur de la List 1 Alors Affecter ܬ+1 à ܬ Fin Si Fin Tant que Fin Si Fin Pour 35 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Enfin pour terminer la première boucle « Tant que », si ܬൌ ܰ, c’est-à-dire si le joueur a tout juste, on continue la partie après un message d'encouragement et une pause qui a pour vocation de laisser le joueur s'apprêter à mémoriser la séquence suivante (la même que précédemment à laquelle on a ajouté une touche). Si le joueur s'est trompé, le jeu s'arrête avec la mention du score : le nombre de touches correctement mémorisées, c’est-à-dire ܰ-1 : Effacer Si ܬൌ ܰAlors Afficher "Bien, On continue ?" Pause Fin Tant que Sortie : Afficher au milieu "Perdu, Votre Score est" Afficher ܰ-1 36 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Voici l'algorithme en entier : Sortie : Afficher "Prêt ?" Pause Initialisation : ܫprend la valeur 0 ܬprend la valeur 0 ܰ prend la valeur 0 Initialiser Liste 1 comme une liste Traitement : Tant que ܬൌ ܰ Effacer Affecter ܰ ͳà ܰ Affecter ܫ ͳà ܫ Affecter Ͳ à ܬ Affecter un nombre entier au hasard entre 1 et 4 à B Si ܤൌ ͳalors Affecter 38 en ܫ-ème position de la liste 1 Fin Si Si ܤൌ ʹalors Affecter 28 en ܫ-ème position de la liste 1 Fin Si Si ܤൌ ͵alors Affecter 27 en ܫ-ème position de la liste 1 Fin Si Si ܤൌ ͳalors Affecter 37 en ܫ-ème position de la liste 1 Fin Si Pour ܶ allant de 1 à ܰ Si le ܶ-ème chiffre de la liste 1 est 38 alors Afficher une flèche vers la gauche Fin Si Si le ܶ-ème chiffre de la liste 1 est 28 alors Afficher une flèche vers le haut Fin Si Si le ܶ-ème chiffre de la liste 1 est 27 alors Afficher une flèche vers la droite Fin Si Si le ܶ-ème chiffre de la liste 1 est 37 alors Afficher une flèche vers le bas Fin Si Effacer Fin Pour Pour ܫallant de 1 à ܰ Affecter 0 à ܣ Si ܬൌ ܫ-1 Alors Tant que ܣൌ Ͳ Affecter la valeur de la touche appuyée à ܣ Si A est égal à la I-ème valeur de la List 1 Alors Affecter ܬ+1 à ܬ Fin Si Fin Tant que Fin Si Fin Pour Effacer Si ܬൌ ܰAlors Afficher "Bien, On continue ?" Fin Si Pause Fin Tant que Sortie : Afficher u milieu "Perdu, Votre Score est" Afficher ܰ-1 37 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Voici le programme en entier sur la Graph 35+E. Plusieurs nouvelles commandes sont utilisées : x Tout d'abord pour effacer l’écran, utiliser la commande ClrText qui se trouve dans [PRGM] (Lo). Faire défiler (u) et sélectionner l'onglet {Clr} (q). x L’algorithme utilise beaucoup de structures conditionnelles Si… Alors… Pour simplifier le programme, il est possible d’utiliser un raccourci à la commande If… Then… IfEnd… Cette commande est symbolisée par "֜" (symbole mathématique de l'implication). Elle se trouve dans [PRGM] (Lo) puis dans l'onglet {JUMP} (e). Elle fonctionne de la façon suivante Condition à respecter֜ Action à effectuer si la condition est respectée. x De plus pour récupérer la valeur d'une touche il nous faut la commande Getkey. Celle-ci se trouve dans [PRGM] (Lo), faire défiler (u) puis sélectionner l'onglet {I/O} (r). x Pour rendre le jeu plus agréable il est possible d’afficher les flèches (qui se trouvent dans l’onglet {CHAR} (u) ) plus au centre de l'écran et à des positions différentes selon que ce soit Haut, Bas,… Pour cela, utiliser la commande Locate qui se trouve dans le même onglet que GetKey (Loupuisr). Locate 8,4," ՚ " signifie que la flèche sera affichée sur la 8èmecolonne et la 4ème ligne (l'écran de la Graph 35+E comporte 8 lignes et 20 colonnes de caractères). Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources NB : La boucle "Pour ܮallant de 1 à 10" sert à allonger la durée de l'affichage de chaque flèche. Sans cela la flèche disparaîtrait trop vite de l'écran et le joueur n'aurait pas le temps de la mémoriser. La boucle "Pour ܱ allant de 1 à 15" sert à faire patienter la calculatrice avant l'appui de la touche par le joueur. Sans cette boucle la calculatrice considérerait le dernier l comme la touche appuyée par le joueur et celui-ci perdrait immédiatement. PS : Voici mon meilleur score à ce jeu, ferez-vous mieux ? 38 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Exemple 13 : Développements Limités Construire un algorithme qui donne un développement limité d’une fonction ࢌ en un point ࢇ à l’ordre ; ࢌǡ ࢇࢋ࢚ étant entrés par l’utilisateur. Rappel : Théorème de Taylor Soit ݂ une fonction définie sur un intervalle ܫǤ Soient ݊ אԳ݁ א ܽݐԹ Si ݂est ݊ fois dérivable en ܽ alors elle admet un développement limité en ܽ à l’ordre ݊ : ܫ א ݔǡ݂ሺݔሻ ൌ σ݊݇ൌͲ ݂ ሺ݇ሻ ሺܽሻ ሺݔ ݇Ǩ െ ܽሻ݇ ሺ ݔെ ܽሻ݊ ൌ ݂ሺܽሻ ݂ ː ሺܽሻሺ ݔെ ܽሻ ݂ ሺ݊ሻ ሺܽሻ ݂ ːː ሺܽሻ ሺ ݔെ ܽሻʹ ڮ ሺ ݔെ ܽሻ݊ ሺ ݔെ ܽሻ݊ ʹǨ ݊Ǩ Pour cet algorithme, nous utilisons une variable ݏinitialisée à 0 dans laquelle nous stockons successivement chaque terme du développement de Taylor grâce à une boucle « Pour ». Voici l’algorithme en langage naturel : Initialisation : ݏprend la valeur 0 Entrée : Saisir ݊ Saisir ݂ሺݔሻ Saisir ܽ Traitement : Pour ݇allant de 0 à ݊ Affecter ݏ ݂ ሺ݇ሻ ሺܽሻ ሺݔ ݇Ǩ െ ܽሻ݇ à ݏ Fin Pour Sortie : 39 Afficher ݏ ሺ ݔെ ܽሻ݊ Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Nous allons avoir besoin de la fx-CP400+E pour programmer cet algorithme. Quelques petites nouveautés par rapport aux programmes précédents : Pour saisir ݂ሺݔሻ, utiliser la commande InputFunc. Aller dans l’onglet {E/S} puis sélectionner Saisir. Pour le calcul de dérivées, la commande diff se trouve dans le clavier Math2 ( ). Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources Voici un exemple avec ݂ሺݔሻ ൌ ݁ ݔǡ ݊ ൌ Ͷ݁ ͵ݐൌ Ͳ 40 Il est possible de vérifier le programme en utilisant directement la commande taylor : dans le menu Principale, sélectionner l’onglet {Intéractif} puis Avancé et enfin taylor. Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E Retrouvez toutes les informations et ressources pédagogiques : www.casio-education.fr CASIO Education [email protected] CASIO calculatrices CASIO FRANCE Société Anonyme au capital de 6 000 000€ - SIREN 431 870 906 - RCS EVRY Siège social : Immeuble Phénix 1 - 24, rue Emile Baudot - F-91120 PALAISEAU - www.casio.fr