1 Manuel d'algorithmique de la Graph 35+E à la fx-CP400+E

1 Manuel d’algorithmique de la Graph 35+E à la fx-CP400+E

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.


Langage

naturel

Langage

algorithmique

Langage Graph 35+E

et Graph 75+E

Langage

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

http://www.casio-education.fr/resources


SOMMAIRE

I. PREMIERS ALGORITHMES : PROGRAMMES DE CALCUL........................................................................ 4

II. AFFECTATION ....................................................................................................................................................... 6

III. STRUCTURE CONDITIONNELLE .................................................................................................................. 7

IV. BOUCLES ........................................................................................................................................................... 9

1. Boucles Pour ......................................................................................................................................................... 9

2. Boucles Tant que ................................................................................................................................................. 11

V. 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


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 :

Entrée : Saisir n

Traitement : Affecter à

Sortie : Afficher

En langage Graph 75+E :

Réalisons maintenant ce programme sur la Graph 75+E

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.

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.

Entrée : Saisir

Sortie : Afficher

On peut même être plus efficace dans l’écriture en langage algorithmique pour n’avoir que deux lignes :


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.

Entrée : Saisir


Sortie : Afficher

Pour la suite du manuel, nous nous concentrerons sur les langages algorithmiques et de programmation.

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.

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] : Lopuis r.

Il ne reste plus qu’à l’exécuter : appuyer deux fois sur dpuis sur q.

Le tester avec trois valeurs 10, 11 et 15.

Langage Graph 75+E :

Langage algorithmique :

Programmons-le sur la Graph 75+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).

Exemple 1 :

Qu'affiche l'algorithme suivant ?

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 .

Sur une Graph 75+E cela donne :

Pour afficher puis , nous allons utiliser la commande « Affichage » symbolisée par un triangle noir : W. Il se trouve dans [PRGM] :Lo puis y.

Entrée : Saisir et


Affecter à

Affecter à

Sortie : Afficher et

- prend la valeur - prend la valeur - Affecter à - Affecter à - Afficher et

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.


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.

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 :

Entrée : Saisir

Traitement : Si

Sortie : Alors Afficher

Sortie : Sinon Afficher

FinSi

Nous stockons dans le nombre de photos commandées.

?

If

Then

Else

IfEnd

En langage Graph 75+E :

- le "Si" se traduit par "If"

- "Alors" par "Then"

- "Sinon" par "Else"

- "FinSi" par "IfEnd".

125 photos coûtent 15€.

36 photos coûtent 5,76€.


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 :

Entrée : Saisir et


Si

Sortie : Alors Afficher « MAIGREUR »

Sinon Si

Sortie : Alors Afficher « SURPOIDS »

Sortie : Sinon Afficher « NORMALE »

FinSi

FinSi

N'avais-je pas dit que l'IMC n'était pas toujours fiable ?

²

?

?

If

Then "MAIGREUR"

Else If

Then "SURPOIDS"

Else "NORMALE"

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 ?

En langage Graph 75+E cela donne :


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 :

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

Sortie : Afficher

Fin Pour

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).

Cet algorithme affiche successivement les nombres 0 ; 1 ; … ; 10.

On effectue donc 11 itérations.

Ne reste plus qu'à l'exécuter. Appuyer à chaque fois sur l pour avoir la valeur suivante.


Exemple 2:

Déterminer la valeur de sortie

de l'algorithme ci-contre.

Programmer l'algorithme sur la Graph 75+E :

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.

Entrée : Saisir

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 :

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).

Exécuter le programme en prenant 7 comme valeur.

La valeur de sortie est 42 lorsqu'on entre 7.

Entrée : Saisir

Traitement : Pour allant de à

Affecter à

Fin Pour

Sortie : Afficher

Exécuter le programme en entrant les valeurs 10 puis 20.


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 :

Il faut donc faire la somme des 141 premiers entiers consécutifs pour dépasser 10 000.

En exécutant le programme on obtient 141.


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


Affecter à

Affecter à

Fin Tant que

Sortie : Afficher

Sur la Graph 75+E, cela donne :

Il faudrait donc 78 mois à Paul pour rembourser son prêt.

En exécutant le programme on obtient :


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.


prend une valeur au hasard entre 1 et 100

Entrée : Saisir


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.


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.


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.

Entrée : Saisir


prend la valeur 1

Traitement : Pour allant de 1 à N

Affecter à

Affecter à

Affecter à

Fin Pour

Sortie : Afficher

Ce qui donne sur la calculatrice :

On peut ainsi calculer le 40ème terme de la suite de Fibonacci :

?

If Intg( )

Then "NON"

Else If Intg( )

Then "NON"

IfEnd

IfEnd

"BISSEXTILE"

Algorithme en langage Graph 75+E :

Ce qui donne sur la Graph 75+E :

Retrouvez le programme en téléchargement gratuit sur :

www.casio-education.fr/resources






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).

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).

Retrouvez le programme en téléchargement gratuit sur : www.casio-education.fr/resources



On peut vérifier que notre approximation est bonne en calculant cette intégrale directement avec la calculatrice :

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 :

Entrée : Saisir

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.

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 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 .

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).

Pour N=5 000, on obtient :


Pour tester la parité nous utilisons la même méthode que pour l'algorithme sur l'année bissextile : on teste si est un entier ou non àl'aide de la fonction "partie entière" (Commande Intg).

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



Affecter à

Si est pair

Alors Affecter à

Sinon Affecter à

Fin Si

Fin Tant que

Sortie : Afficher

Regardons le temps de vol lorsque :

Le temps de vol de 169 est de 49.

Sur la Graph 75+E cela donne :





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


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.





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 lui-mê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



Si est divisible par

Alors

Affecter à

Fin Si

Fin Pour

Si

Alors

Sortie : Afficher "Parfait"

Sinon

Sortie : Afficher "Non parfait"

Fin Si

En l'exécutant avec n'importe quelle valeur on obtient : 495.

L'algorithme de Kaprekar converge vers 495.

On teste les diviseurs jusqu'à la partie entière de (car un diviseurpropre 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 1 à , il ne reste plus qu'à vérifiersi la somme des diviseurs est égale au nombre, c’est-à-dire si . Si c'est le cas, le nombre est parfait.

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).


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



prend la valeur 0

Pour allant de 1 à

Si est divisible à par

Alors

Affecter à

Fin Si

Fin Pour

Si

Alors

Sortie : Afficher

Fin Si

Fin Pour

Voici l'algorithme programmé sur la Graph 35+E :

Et les nombres parfaits inférieurs ou égaux à 500 sont :





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 à


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 : Afficher Liste 1


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.

Ci-contre, l’algorithme programmé sur la fx-CP400+E.

Initialiser une liste consiste à affecter {} à .






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 :

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.

On peut le tester avec par exemple 57 et 654 :





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 trouvedans 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 dansOPTION (i) puis dans l'onglet {COMPLEX} (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 :


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

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 :


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 :

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é




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


Programmation avec la fx-CP400+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.

Pour , on obtient :

Exemple de programmation avec la Graph 75+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 :

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


Affecter comme -ème terme de la liste

Affecter - à

Fin Pour



Affecter +1 à

Fin Tant que


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 :


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 -ème chiffre de ) à

Affecter à

Affecter 1 à

Fin Si

Fin Si

Affecter - à

Fin Tant que

Sortie : Afficher


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


est une liste

prend la valeur 1

prend la valeur 0


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 -ème chiffre de ) à

Sinon Si le et le -1-ème chiffre de sont égaux

Alors Affecter +1 à

Sinon Affecter -ème chiffre de ) à

Affecter +2 à

Affecter 1 à

Fin Si

Fin Si

Affecter -1 à

Fin Tant que

Sortie : Afficher

Fin Pour


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 :

En utilisant ce programme, afficher les cinq premiers termes de la suite de premier terme 1223 :

Sortie : Afficher "Prêt ?"

Pause

Programmation de l’algorithme sur la fx-CP400+E.

Rappel : Initialiser une liste consiste à Affecter {} à .




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


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





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 touchespré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


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


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


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.

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).

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.

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).

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).

Plusieurs nouvelles commandes sont utilisées :

Voici le programme en entier sur la Graph 35+E.

PS : Voici mon meilleur score à ce jeu, ferez-vous mieux ?




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 :


Entrée : Saisir

Saisir

Saisir


Affecter à

Fin Pour

Sortie : Afficher


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 ( ).

Voici un exemple avec

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.



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

Retrouvez toutes les informations et ressources pédagogiques :

CASIO Education CASIO calculatrices

[email protected]

http://www.casio-education.fr

mailto:[email protected]

http://www.casio.fr

https://www.youtube.com/c/casioeducation

https://www.facebook.com/CasioCalculatrices

Documents

1 Manuel d'algorithmique de la Graph 35+E à la fx-CP400+E