Les instructions de programmation

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