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

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 : On peut même être plus efficace dans l’écriture en

langage algorithmique pour n’avoir que deux lignes :
Entrée : Saisir n
Entrée : Saisir ݊
Traitement : Affecter ሺ݊ ൅ ͹ሻʹ െ ͵ à ‫ܣ‬
Sortie : Afficher ‫ܣ‬ Sortie : Afficher ሺ݊ ൅ ͹ሻʹ െ ͵
En langage Graph 75+E :
ǫ՜ ܰ
ሺܰ ൅ ͹ሻʹ െ ͵
‫ܣ‬
Réalisons maintenant ce programme sur la Graph 75+E
Dans le menu principal, Donner un nom au

sélectionner le menu Créer un nouveau programme, ici par exemple
PROGRAMME : ag. programme e. CALCUL.
Enfin, terminer le
Ensuite accéder à programme. Pour
[PRGM] :Lo. Puis l’exécuter, sortir de l’éditeur Sélectionner ensuite
sélectionner le point de programme en appuyant l’onglet {EXE}: q.
d’interrogation : r. deux fois sur d.

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.

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 ʹ
Exemple 1 : - ‫ ܤ‬prend la valeur െ͵
- 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 Entrée : Saisir ܺ et ܻ

fonctionne pas car, au final, l’algorithme afficherait deux fois la
valeur entrée dans ܺ, la valeur entrée dans ܻ étant « écrasée » Traitement : Affecter ܻ à ܼ
par l’affectation de ܺ dans ܻ. Affecter ܺ à ܻ
Il faut donc utiliser une troisième variable dite « de transfert » Affecter ܼ à ܺ

pour stocker la valeur de la variable ܻ au tout début de Sortie : Afficher ܺ et ܻ
l’algorithme.
Sur une Graph 75+E cela donne :

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 : Saisir ܰ
Traitement : Si ܰ ൒ ͹ͷ
Nous stockons dans ܰ le nombre de
photos commandées. 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€.

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 » Else If ‫ ܫ‬൐ ʹͷ
Sortie : Sinon Afficher « NORMALE » 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 ?

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 Les boucles pour répéter une instruction un certain nombre de fois, il s'agit des boucles « Pour ».
x 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 Cet algorithme affiche successivement les nombres

0 ; 1 ; … ; 10.
Sortie : Afficher ݅
Fin Pour 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.

Exemple 2: Entrée : Saisir ݇
Déterminer la valeur de sortie Traitement : Pour ࢏ allant de ͳ à ͳͲ
de l'algorithme ci-contre. Affecter ݇ ൅ ݅ െ ʹ à ݇

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

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

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

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

Ce qui donne sur la
Algorithme en langage Graph 75+E : 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 ܹ à ܸ Retrouvez le programme en
Fin Pour www.casio-education.fr/resources
Sortie : Afficher ܸ
On peut ainsi calculer le 40ème terme de la suite de

Fibonacci :

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 :


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 :
Entrée : Saisir ݊
Initialisation : Changer la fenêtre graphique : ܺ݉݅݊ ൌ ͲǢ ܺ݉ܽ‫ ݔ‬ൌ ͳ ; ܺ݃‫ ݀ܽݎ‬ൌ Ͳǡͳ
ܻ݉݅݊ ൌ Ͳ; ܻ݉ܽ‫ ݔ‬ൌ ͳǢܻ݃‫ ݀ܽݎ‬ൌ Ͳǡͳ

‫ ݔ‬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.

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 :

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
Affecter ܰ ൅ ͳ à ܰ
l'algorithme sur l'année bissextile :
Si ܷ est pair on teste si
ܷ
est un entier ou non à
ʹ
ܷ
Alors Affecter àܷ l'aide de la fonction "partie entière"
ʹ
(Commande Intg).
Sinon Affecter ͵ܷ ൅ ͳ à ܷ
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

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

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 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 ݊
Initialisation : ‫ ݏ‬prend la valeur 0
On teste les diviseurs jusqu'à la
݊ ݊
Traitement : Pour ݅allant de 1 à ‫ ܧ‬ቀʹ ቁ partie entière de (car un diviseur
ʹ
propre ne peut être plus grand que la
Si ݊ est divisible par ݅
moitié du nombre).
Alors
La variable ‫ ݏ‬stocke la somme des
Affecter ‫ ݏ‬൅ ݅ à ‫ݏ‬
diviseurs.
Fin Si
Une fois testés tous les nombres de
Fin Pour ݊
1 à ‫ ܧ‬ቀʹ ቁ, il ne reste plus qu'à vérifier
Si ‫ ݏ‬ൌ ݊ si la somme des diviseurs est égale
Alors au nombre, c’est-à-dire si ‫ ݏ‬ൌ ݊ . Si
c'est le cas, le nombre est parfait.
Sortie : Afficher "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).

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

Ci-contre, l’algorithme programmé sur la
fx-CP400+E.
Initialiser une liste consiste à affecter {} à ‫ ͳܮ‬.
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.

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

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 Un exemple de trajet :
dans l’onglet {E/S} puis sélectionner Tracé
Retrouvez le programme en téléchargement

gratuit sur : www.casio-education.fr/resources

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

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 :

Programmation avec la fx-CP400+E :
Pour ݊ ൌ ͷͲͲ, on
obtient :

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

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

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
Fin Pour

Programmation de l’algorithme sur la fx-CP400+E.
En utilisant ce programme, afficher
Rappel : Initialiser une liste ‫ ͳܮ‬consiste à Affecter {} à ‫ ͳܮ‬. les cinq premiers termes de la suite
de premier terme 1223 :

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

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

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

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 28 en ‫ܫ‬-ème position de la liste 1 Fin Si
Si ‫ ܤ‬ൌ ͵alors Affecter 27 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

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 ?

Exemple 13 : Développements Limités
ࢌ en un point ࢇ à
Construire un algorithme qui donne un développement limité d’une fonction
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 : 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 ( ).

Il est possible de vérifier le programme en utilisant

directement la commande taylor : dans le menu
Voici un exemple avec
݂ሺ‫ݔ‬ሻ ൌ ݁ ‫ ݔ‬ǡ ݊ ൌ Ͷ݁‫ ͵ݐ‬ൌ Ͳ Principale, sélectionner l’onglet {Intéractif} puis
Avancé et enfin taylor.

Retrouvez toutes les informations et ressources pédagogiques :
www.casio-education.fr education-france@casio.fr
CASIO Education 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

Manuel D'algorithmique de La Graph 35 E À La Fx-CP400 E

Transféré par

Droits d'auteur :

Formats disponibles

Manuel D'algorithmique de La Graph 35 E À La Fx-CP400 E

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Manuel D'algorithmique de La Graph 35 E À La Fx-CP400 E

Transféré par

Droits d'auteur :

Formats disponibles

Qu’est-ce qu’un 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.

Sortie(s) : Affichage du ou des résultats.

Un algorithme peut être écrit en langage naturel, en langage algorithmique ou en langage de

Le langage naturel est l’écriture de l’algorithme sous forme de phrases intelligibles.

Le langage de programmation est la « traduction » du langage algorithmique à l’aide des commandes

1 Manuel d’algorithmique de la Graph 35+E à la 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

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

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

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

Voici un algorithme en langage naturel :

En langage algorithmique : On peut même être plus efficace dans l’écriture en

En langage Graph 75+E :

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

Dans le menu principal, Donner un nom au

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

Exemple 2 : Moyenne arithmétique

Langage Graph 75+E :

Programmons-le sur la Graph 75+E :

Dans le menu PROGRAMME, créer un nouveau

Ensuite taper le programme.

Rappel : le point d’interrogation est dans [PRGM] : Lo

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

Le tester avec trois valeurs 10, 11 et 15.

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

Pour afficher ‫ ܣ‬puis ‫ܤ‬, nous allons utiliser la commande

Exemple 2 : Inversion d’une variable

Le premier réflexe est d’affecter ܺ à ܻ puis ܻ à ܺ. Mais cela ne Entrée : Saisir ܺ et ܻ

Il faut donc utiliser une troisième variable dite « de transfert » Affecter ܼ à ܺ

Sur une Graph 75+E cela donne :

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

En langage Graph 75+E :

- le "Si" se traduit par "If" If ܰ ൒ ͹ͷ

- "FinSi" par "IfEnd". IfEnd

Sur une Graph 75+E cela donne :

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

En langage Graph 75+E cela donne :

Ci-contre, l'algorithme programmé sur la Graph 75+E.

Le capitaine de l'équipe de France de rugby, Thierry

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

Le passage dans une boucle est appelé itération.

Traitement : Pour ࢏ allant de 0 à 10 Cet algorithme affiche successivement les nombres

En langage Graph 75+E, cela donne :

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

de l'algorithme ci-contre. Affecter ݇ ൅ ݅ െ ʹ à ݇

Programmer l'algorithme sur la Graph 75+E :

La valeur de sortie est 42

On place un capital de 10 000 € au taux de 4 % annuel.

Programmer l'algorithme sur la Graph 75+E :

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