Previous Up Next

Chapitre 2  Les instructions de programmation

2.0.3  Généralités

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:

a:=1

On tape pour définir la fonction f(x)=2*x+√x :

f(x):=2*x+sqrt(x)

On tape pour définir la procédure Carre :

Carre(x):={repete(4,avance(x),tourne_gauche)}

Un booléen a comme valeur 0 (faux) ou 1 (vrai),
les booléens (ie les conditions) peuvent être obtenus avec les signes

== qui teste l’égalité (toutefois on admet = pour tester l’égalité dans les instructions si et tantque),
< > <= >= qui testent les inégalités,
!= qui teste la différence.

Les opérateurs sur les booléens sont ou, et, non.
On tape :

0 et 1

Ou on tape :

0 and 1

On obtient :

0

On tape :

0 ou 1

Ou on tape :

0 or 1

On obtient :

1

On tape :

0 > 1

On obtient :

0

On tape :

non(0 <1)

Ou on tape :

not(0 <1)

On obtient :

1

2.0.4  Pour choisir : si...alors...sinon...fsi

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 :

a:=3; si a==3 alors avance 10*a; sinon avance; fsi

Ou on tape :

a:=3; if (a==3) {avance(10*a);} else {avance;}

On obtient :

La tortue avance de 30 pas

2.0.5  Pour répéter les mêmes instructions: repete

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 :

repete 3,avance 40,tourne_droite 120

Ou on tape :

repete 3,avance(30),tourne_droite(120)

Ou on tape :

repete(3,avance 30,tourne_droite 120)

Ou on tape :

repete(3,avance(30),tourne_droite(120))

On obtient :

Un triangle équilatéral de cotés 30

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

2.0.6  Pour faire n fois une boucle : pour...de ...jusque... pas...faire...fpour

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 :

pour n de 1 jusque 10 faire avance 10*n;tourne_gauche;fpour

Ou on tape :

for (n:=1;n<=10;n:=n+1){avance 10*n;tourne_gauche;}

On obtient :

La tortue dessine un morceau de frise grecque en partant du centre

On tape :

pour n de 10 jusque 1 pas -1 faire avance 10*n;tourne_gauche;fpour

Ou on tape :

for (n:=10;n>=1;n:=n-1){avance 10*n;tourne_gauche;}

On obtient :

La tortue dessine un morceau de frise grecque mais en partant de l’extérieur

2.0.7  Pour faire une boucle : tantque...faire...ftantque

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 :

La tortue dessine un morceau de frise grecque

2.0.8  Pour faire une boucle en utilisant la récursivité

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 :

polygo(n,p,a):=repete(p,avance(a),tourne_gauche(360/n))

Puis on tape dans un niveau de l’écran tortue :

efface;dessine_tortue;polygo(6,5,50)

On obtient :

Les 5 cotés d’un hexagone de côtés 50

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 :

efface;dessine_tortue;tria1(5,100)

On obtient :

5 triangles équilatèraux, le deuxième triangle a pour sommet les milieux des cotés du premier triangle etc ...

c’est à dire le même dessin que précédemment.

2.0.9  Pour définir une fonction : retourne

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 :

La fonction booléenne qui teste si il y a un zéro dans une liste

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.

2.0.10  Pour lire une expressionà partir du clavier : lis

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 :

pilote(a) d a d a d a f

On obtient :

un carré

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 :

A:=piloter(a)

Puis :

d a d a d a f

On obtient :

un carré

Puis on tape :

A

On obtient :

"avance;tourne_droite;avance;tourne_droite;
avance;tourne_droite;avance;tourne_droite"

Puis on tape :

efface;execute(A)

On obtient à nouveau :

un carré

2.0.11  Pour lire une chaîne de caractères à partir du clavier : lis_phrase

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 :

conduite("a") d a d a d a f

On obtient :

un carré

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 :

A:=conduire("a") d a d a d a f

On obtient :

un carré

Puis on tape :

A

On obtient :

"avance;tourne_droite;avance;tourne_droite;
avance;tourne_droite;avance;tourne_droite"

Puis on tape :

efface;execute(A)

On obtient à nouveau :

un carré

2.0.12  Pour exécuter une chaîne de caractères : execute

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 :

execute(" tourne_droite;avance 40; rectangle_plein(20,40);avance -40")

On obtient :

le dessin d’un "drapeau"

2.1  Faire un dessin pas à pas en le mémorisant

2.1.1  Pour enregistrer les commandes : debut_enregistrement

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 :

tourne_gauche
debut_enregistrement(arbre)

Puis on tape les instructions pour définir arbre par exemple :

avance 50

Puis

disque_centre 20

Puis

recule 40

Puis on termine l’enregistrement avec :

fin_enregistrement("arbre.tor")

On obtient :

Un fichier arbre.tor qui content les instructions d’une procédure qui a comme nom arbre

On tape :

efface;tourne_gauche;
arbre()

On obtient :

Le dessin de nôtre arbre

2.1.2  Pour terminer l’enregistrement : fin_enregistrement

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 :

debut_enregistrement(arbre)

Puis on tape les instructions pour définir arbre, puis on tape :

fin_enregistrement("arbre.tor")

On obtient :

Le fichier arbre.tor contenant la procédure arbre

2.2  Faire un dessin en écrivant une procédure

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 :

Le dessin qui a comme nom arbre : on remarque que la tortue n’est pas revenue à sa position de départ

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 :

efface;tourne_gauche;dessine_tortue;arbres(50,20)

On obtient :

Le dessin précédent

2.3  Mettre et retrouver des procédures dans un fichier

2.3.1  Écrire des procédures dans un fichier : sauve

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 :

sauve("toto.tor",tete,bras)

On obtient :

le fichier "toto.tor" contenant les procédures tete et bras

On tape :

sauve("toto.tor",tete,bras)

On obtient :

le fichier "toto.tor"contenant les procédures tete et bras

2.3.2  Utiliser les procédures écrites dans un fichier : ramene

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 :

ramene("toto.tor")

On obtient :

la validation des procédures tete et bras

Previous Up Next