Il faut savoir que :
; termine une instruction,
:= permet d’affecter une variable ou de définir une fonction ou une
procédure.
On tape pour affecter une variable:
On tape pour définir la fonction f(x)=2*x+√x :
On tape pour définir la procédure Carre :
Un booléen a comme valeur 0 (faux) ou 1 (vrai),
les booléens (ie les conditions) peuvent être obtenus avec les signes
Les opérateurs sur les booléens sont ou, et, non.
On tape :
Ou on tape :
On obtient :
On tape :
Ou on tape :
On obtient :
On tape :
On obtient :
On tape :
Ou on tape :
On obtient :
si <condition> alors <instructions1;> sinon <instructions2;> fsi
permet d’effectuer les <instructions1;> lorsque la condition est
satisfaite et d’effectuer les <instructions2;> lorsque la condition n’est
pas satisfaite.
On tape :
Ou on tape :
On obtient :
Pour faire plusieurs fois de suite plusieurs instructions on utilise
repete.
repete a comme argument un entier (le nombre de fois) et la suite
d’instructions séparées par une virgule.
On tape :
Ou on tape :
Ou on tape :
Ou on tape :
On obtient :
Attention
Si on veut utiliser un repete dans un autre repete il faut le
parenthéser c’est à dire mettre à l’extérieur de repete soit
() soit [] : (repete....) ou [repete....].
On tape par exemple :
repete(2,(repete(3,avance(20),tourne_gauche(30))),tourne_droite)
ou
repete(2,[repete(3,avance(20),tourne_gauche(30))],tourne_droite)
qui dessine 2 arcs "hexagonaux", ce qui est différent de :
repete(2,repete(3,avance(20),tourne_gauche(30)),tourne_droite)
qui équivaut à :
repete(2,repete(3,avance(20),tourne_gauche(30),tourne_droite))
et qui dessine l’hexagone :
repete(6,avance(20),tourne_droite(60))
pour k de k1 jusque k2 pas p faire <instructions;> fpour permet de faire les instructions en faisant varier k de k1 jusqu’à
k2 en faisant des pas de p (si p=1 pas p peut être omis).
Bien sûr k peut être remplacé par un autre nom de variable et en
général les instructions à faire dépendent de cette variable car sinon
on utilise repete
On tape :
Ou on tape :
On obtient :
On tape :
Ou on tape :
On obtient :
tantque <condition> faire <instructions;> ftantque permet de
faire les instructions tant que la condition est satisfaite.
On ouvre un éditeur de programme (Alt+p et on tape :
dessine_tortue; n:=100; tantque (n>0) faire avance n; tourne_gauche; n:=n-10; ftantque;
Ou on tape :
dessine_tortue;
n:=100;
while (n>0) {
avance n;
tourne_gauche;
n:=n-10;
}:;
Puis on compile en appuyant sur OK ou sur F9 et on obtient :
Une procédure récursive est une procédure qui s’appelle elle-même mais
avec des paramètres différents et comporte un test d’arrêt qui permet
d’interrompre cet appel.
On tape dans un éditeur de programmes puis on compile en appuyant sur OK
ou sur F9 :
polygo(n,p,a):={
si p!=0 alors
avance(a);
tourne_gauche(360/n);
polygo(n,p-1,a);
fsi;
}:;
Ou on tape en utilisant si...alors...fsi au lieu de if...{...} :
polygo(n,p,a):={
si (p!=0) alors
avance(a);
tourne_gauche(360/n);
polygo(n,p-1,a);
fsi;
};
Ou on tape une procédure non récursive en utilisant repete :
Puis on tape dans un niveau de l’écran tortue :
On obtient :
On veut faire une suite de n triangles équilatèraux : le premier a pour
côtés a, le deuxième a pour sommet les milieux des cotés du premier
triangle etc ...
On suppose que la tortue a comme position de départ :
un sommet du premier triangle et est dirigée selon un coté et que
les triangles sont situés sur sa gauche (si vous choisissez les triangles
sont situés sur sa droite, il suffira de changer les tourne_droite en
tourne_gauche et vice-versa). On choisit la même position comme
position d’arrivée.
Voici deux procédures récursives.
On dessine le premier triangle, puis on place la tortue à l’endroit où il
faut être pour faire l’appel récursif, on fait l’appel récursif,
et on ramene la tortue à sa position de départ.
On tape par exemple dans un éditeur de programmes puis on compile en appuyant
sur OK ou sur F9 :
tria(n,a):={
si n!=0 alors
repete(3,avance(a),tourne_gauche(120));
avance(a/2);
tourne_gauche(60);
tria(n-1,a/2);
tourne_droite(60);
avance(-a/2);
fsi;
}:;
On tape :
efface;dessine_tortue;tria(5,100)
On obtient :
Ou pour ne pas repasser sur le même trait, on commence à dessiner le
début du premier triangle, puis on place la tortue à l’endroit où il faut
être pour faire l’appel récursif, on fait l’appel récursif, puis on
finit de dessiner le premier triangle et on ramène la tortue à sa position
de départ.
On tape :
tria1(n,a):={
si n!=0 alors
avance(a/2);
tourne_droite(60);
tria1(n-1,a/2);
tourne_gauche(60);
avance(a/2);
tourne_droite(120);
repete(2,avance(a),tourne_droite(120));
fsi;
}:;
Puis on tape :
On obtient :
c’est à dire le même dessin que précédemment.
retourne a un argument qui est la valeur que l’on veut donner
à la fonction.
retourne permet d’interrompre le programme et de renvoyer l’argument
de retourne comme étant la valeur de la fonction que l’on définit.
On tape pour avoir une fonction booléenne qui nous dit si il y a un terme nul dans une liste l :
zerodansl(l):={
pour k de 0 jusque size(l)-1 faire
si l[k]==0 alors
retourne(1);
fsi;
fpour;
retourne(0);
}:;
Ou on tape :
zeroinl(l):={
for (k:=0;k<size(l);k++){
if (l[k]==0) retourne(1);
}
retourne(0);
}:;
On obtient :
Remarque
Lorsqu’on fait un dessin tortue, on écrit une procédure : cette procédure
va exécuter toutes les instructions graphiques et renvoie automatiquement
l’état de la tortue. On n’a donc pas besoin d’utiliser retourne, sauf
si on a besoin de transmettre un résultat.
lis a un argument qui est le nom d’une variable.
lis interrompt le programme et ouvre une petite feneêtre qui permet
d’entrer une expression qui sera la valeur de l’argument de lis : si
l’expression est une chaîne de caractères il faut mettre des
guillemets.
On tape :
pilote(l):={
si l==f alors retourne 1;fsi;
si l==e alors L:=L,"efface";efface; fsi;
si l==a alors avance; fsi;
si l==r alors recule; fsi;
si l==d alors tourne_droite; fsi;
si l==g alors tourne_gauche; fsi;
lis(l);
pilotee(l);
}:;
Puis on tape :
On obtient :
Si on veut garder les instructions qui ont été exécutées, On peut
renvoyer une chaine de caractères contenant ces instructions separées par
des ;.
On tape :
piloter(l):={
local L;
si l==f alors retourne "";fsi;
si l==e alors L:="efface;";efface; fsi;
si l==a alors L:="avance;";avance; fsi;
si l==r alors L:="recule;";recule; fsi;
si l==d alors L:="tourne_droite;";tourne_droite; fsi;
si l==g alors L:="tourne_gauche;";tourne_gauche; fsi;
lis(l);
retourne L+piloter(l);
}:;
Puis on tape :
Puis :
On obtient :
Puis on tape :
On obtient :
Puis on tape :
On obtient à nouveau :
lis_phrase a un argument qui est le nom d’une variable.
lis_phrase interrompt le programme et ouvre une petite feneêtre qui
permet d’entrer une chaîne de caractères qui sera la valeur de
l’argument de lis_phrase : on tape la chaîne de caractères sans
mettre les guillemets.
On tape :
conduite(l):={
si l=="f" alors retourne 1;fsi;
si l=="e" alors efface; fsi;
si l=="a" alors avance fsi;
si l=="r" alors recule fsi;
si l=="d" alors tourne_droite; fsi;
si l=="g" alors tourne_gauche; fsi;
lis_phrase(l);
conduite(l);
}:;
Puis on tape :
On obtient :
Si on veut garder la suite des instructions qui a été exécutée, on peut
renvoyer une chaine de caractères contenant ces instructions separées par
des ;.
On tape :
conduire(l):={
local L;
si l=="f" alors retourne "";fsi;
si l=="e" alors L:="efface;";efface; fsi;
si l=="a" alors L:="avance;";avance; fsi;
si l=="r" alors L:="recule;";recule; fsi;
si l=="d" alors L:="tourne_droite;";tourne_droite; fsi;
si l=="g" alors L:="tourne_gauche;";tourne_gauche; fsi;
lis_phrase(l);
retourne L+conduire(l);
}:;
Puis on tape :
On obtient :
Puis on tape :
On obtient :
Puis on tape :
On obtient à nouveau :
execute a comme argument chaîne de caractères qui est
une suite de commande. L’argument doit être mis entre des parenthèses
execute exécute cette suite de commande.
On tape :
On obtient :
debut_enregistrement a comme argument un nom de procédure.
debut_enregistrement va permettre d’enregistrer les commandes comprises
entre debut_enregistrement et fin_enregistrement et ainsi
définir une procédure du nom donné en argument de
debut_enregistrement.
On tape :
Puis on tape les instructions pour définir arbre par exemple :
Puis
Puis
Puis on termine l’enregistrement avec :
On obtient :
On tape :
On obtient :
fin_enregistrement a comme argument une chaine de caractères.
fin_enregistrement sauve la procédure définie par les instructions
comprises entre debut_enregistrement et fin_enregistrement
dans le fichier dont le nom est passé en argument de fin_enregistrement.
On tape :
Puis on tape les instructions pour définir arbre, puis on tape :
On obtient :
On peut écrire une procédure dans l’éditeur de programmes.
On tape les instructions pour définir arbre par exemple :
arbre():={
avance 50;
disque_centre 20;
recule 40;
}:;
Puis on tape :
tourne_gauche; dessine_tortue; arbre() }:;
On obtient :
On tape les instructions pour définir arbre avec deux paramètres :
arbres(a,b):={
avance a;
disque_centre b;
recule 2*b;
}:;
Puis on tape :
On obtient :
sauve a comme argument une chaîne de caractères qui est
le nom d’un fichier et le nom des procédures et des variables que l’on veut
sauver dans ce fichier.
sauve permet de mettre en mémoire ces procédures dans ce fichier
et donc de pouvoir les réutiliser dans une autre session de travail.
On tape :
On obtient :
On tape :
On obtient :
ramene a comme argument une chaîne de caractères qui
est le nom d’un fichier contenant des procédures agissant sur la tortue.
ramene permet de valider et donc d’utiliser les procédures
se trouvant dans ce fichier.
On tape :
On obtient :