1 Manuel d`algorithmique de la Graph 35+E à la fx

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