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):={repate(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 booléens doivent toujours être entourées de parenthèses () dans les instructions si et tantque,
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 tape :

n:=100;tantque (n>0) faire avance n;tourne_gauche;n:=n-10;ftantque

Ou on tape :

n:=100;while (n>0) {avance n;tourne_gauche;n:=n-10;}

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 :

polygo(n,p,a):={ if (p!=0){ avance(a); tourne_gauche(360/n); polygo(n,p-1,a); } }

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 :

polygo(6,4,20)

On obtient :

Les 4 cotés d’un hexagone de côtés 20

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 droite (si vous choisissez les triangles sont situés sur sa gauche, 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 :

tria(n,a):={ if (n!=0){ repete(3,avance(a),tourne_droite(120)); avance(a/2); tourne_droite(60); tria(n-1,a/2); tourne_gauche(60); avance(-a/2); } }

Ou 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 ramene la tortue à sa position de départ.
On tape :

tria(n,a):={ if (n!=0){ avance(a/2); tourne_droite(60); tria(n-1,a/2); tourne_gauche(60); avance(a/2); tourne_droite(120); repete(2,avance(a),tourne_droite(120));}}

Puis on tape :

tria(5,100)

On obtient :

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

2.0.9  Pour définir une fonction : return

return a un argument qui est la valeur que l’on veut donner à la fonction.
return permet d’interrompre le programme et de renvoyer l’argument de return comme étant la valeur de la fonction que l’on définit.
On tape :

zerodansl(l):={pour k de 0 jusque size(l)-1 faire si l[k]==0 alors return(1);fsi; fpour; return(0);}

Ou on tape :

zeroinl(l):={for (k:=0;k<size(l);k++){if (l[k]==0) return(1);} return(0);}

On obtient :

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

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 mettres les guillemets.
On tape :

conduite(l):={ si l==f alors return 0;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); conduite(l); }

Puis on tape :

conduite(a) d a d a d a f

On obtient :

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 return 0;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é

2.0.12  Pour executer une chaîne de caractères : execute

execute a comme argument chaîne de caractères qui est une suite de commande.
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 :

debut_enregistrement(arbre)

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

avance 40

Puis

disque 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;
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 40;disque 20;recule 40}

Puis on tape :

arbre()

On obtient :

Le dessin qui a comme nom arbre

On tape les instructions pour définir arbre avec un paramètre :

arbre(a):={avance 2*a;disque a;recule 2*a}

Puis on tape :

arbre(20)

On obtient :

Le dessin qui est un arbre de paramètre 20

2.3  Éxécution en pas à pas d’une procédure

On peut mettre une suite d’instrucrtions dans prg, puis on demande que l’écran se coupe selon 2 fenêtres (menu Edit sous-menu Fenêtres puis 2 Fenêtres).
On appuie sur geo pour voir la tortue sur un des écrans et sur prg pour voir les instructions.
Puis on met en surbrillance la première ligne de prg et on appuie sur le bouton exec de la barre de boutons de prg.
À chaque exec les instructions sont exécutées et visualisées sur l’écran geo.

2.4  Mettre et retrouver des procédures dans un fichier

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