Le principe de la variable est de pouvoir stocker des informations en mémoire pour pouvoir les réutiliser ensuite. On dit que l’on «attribue» à une variable une valeur. Cette attribution s’écrit de la manière suivante :
toto ← 21
Dans cet exemple j’ai attribué à ma variable «toto» la valeur 21.
toto ← 21
toto ← 12
A ce stade, la valeur de «toto» est «12». J’ai remplacé, lors de la seconde instruction, son contenu.
En algo, comme dans un langage classique, nous manipulons des donnés de types différents. Les «types de bases» sont les suivants :
ENTIER : Nombre entier (négatifs comme positifs)
RÉEL : Nombre décimal, division, etc...
CHAINE : Chaine de caractère. Les chaines doivent être ecrites entre des guillements doubles «» et peuvent être «concaténées»
(càd ajoutées entre elles) grace à l’opérateur «,» (virgule).
toto ← «Aloha l’ami, » , «ça farte?»
La variable variable toto contient désormais la chaîne «Aloha l’ami, ça farte?».Les constantes sont des variables qui ne peuvent être modifiées pendant l’execution du code. On lui attribue une valeur en début de programme, puis on ne peut que la lire.
Pour que nos variables soient prises en compte par le programme,
il faut au préalable les déclarer, c’est à dire annoncer leur nom et leur type.
Ici, une variable de type entier portant le nom de «toto» ainsi que deux variables,
titi et tata - des réels - ont été déclarées.
Le nom de la variable est libre.
Cependant, il ne faut pas qu’il contienne d’espaces, ou d’accents.
Par convention, les constantes sont en majuscule.
CONST
TUTU ← 20 : entier
VAR
toto : entier
titi,tata : chaines
PROGRAMME nom_du_programme
CONST
// ici la déclaration des constantes
TUTU ← 20 : entier
VAR
// ici la déclaration des variables
toto : entier
titi,tata : chaines
DEBUT
/* le corps du programme
c’est ici que nous effectuerons les principales opérations */
toto ← 3
titi ← «loulou?»
FIN
Voila comment se structure un programme.Pour interragir avec l’utilisateur, et donc afficher on modifier le contenu de variables, nous utilisons des mots clefs : AFFICHER et SAISIR.
toto ← 5
AFFICHER «Entrez un nombre»
SAISIR toto
AFFICHER toto
Au début, «toto» vaut 5 (première ligne). Demande à l’utilisateur d’entrer un nombre et celui-ci sera stocké dans «toto».
Au final, on affiche le contenu de la variable «toto», c’est à dire le nombre saisi par l’utilisateur.
AFFICHAGE s’arrange pour présenter à nos yeux du texte. Ainsi, on peut allègrement mélanger les types de variables.
//une chaine, un réel et un entier
fruit ← «pomme»
prix ← 5,3
quantité ← 14
AFFICHER fruit , « (» , quantité , «) : » , prix , « roupies népalaises»
// Affichera «pomme (14) : 5,3 roupies népalaises»
SI toto = 4 ALORS
AFFICHER «toto est égal à» , toto
SINON
AFFICHER «toto n’est pas égal à 4!»
FINSI
Dans cette structure conditionnelle, la première partie du code est éxécutée si la condition entre «SI» et «ALORS» est évaluée à VRAI.
Ainsi, dans l’exemple du dessus, si toto est effectivement égal à 4, le code entre «ALORS» et «SINON» sera éxécuté.
Dans le cas contraire, c’est le code entre «SINON» et «FINSI» qui le sera.
SI bouboule = VRAI ALORS
AFFICHER «Cette variable est évaluée à VRAI»
FINSI
Peut aussi s’écrire :
SI bouboule ALORS
AFFICHER «Cette variable est évaluée à VRAI»
FINSI
Explications : «bouboule = VRAI» est une égalité, soit vraie, soit fausse.
Comme ma variable est un booléen, le «résultat» de cette évaluation sera égal à la variable elle même.
Cela peut paraitre complexe dit comme ça, mais c’est un des fondement de l’algorithme.
Toutes les égalités et inégalités sont «évaluées» de la même manière et c’est le résultat «VRAI» ou «FAUX» qui sera pris en compte.
toto ← «oui»
SI toto = «oui» ALORS
AFFICHER « toto dis oui »
SINON
SI toto = «non» ALORS
AFFICHER « toto dis non »
SINON
AFFICHER « toto dis n’importe quoi »
FINSI
FINSI
Ce code peut être également écrit de la manière suivante :
toto ← «oui»
SELON toto FAIRE
«oui» :
AFFICHER « toto dis oui »
«non» :
AFFICHER « toto dis non »
DEFAUT :
AFFICHER « toto dis n’importe quoi »
FINSELON
Pour deux choix, le gain n’est pas important, mais imaginez 10 conditions «SI» imbriquées :
la lisibilité du code en serait grandement affectée. Pour cela nous utilisons le choix «SELON».
Dans ce choix, on teste l’égalité de la variable (ici «toto») avec differents «cas» (ici «oui» ou «non»).
Si le contenu de la variable testée ne correspond à aucun des cas, c’est le code après «DEFAUT» qui sera éxécuté.
ATTENTION : ce choix est valable (en algo) uniquement pour tester des égalité. Ce code :
SI jours > 14 ALORS
AFFICHER «Nous sommes dans la seconde quinzaine»
FINSI
n’aura pas d’équivalent en terme de choix «SELON».
FAIRE
DISPOSER une couche de pâtes
VERSER sauce tomate
VERSER sauce bechamelle
REPETER JUSQUA plus de pâte
L’action comprise dans la boucle (ici une boucle «FAIRE .. REPETER TANT QUE») sera executée autant de fois que j’ai de la pâte : «plus de pâte» est ma condition de sortie.
Le code s’éxécute AU MOINS une fois. Arrivé à la fin de la boucle, la condition de sortie est testée, et si elle est évaluée à VRAI on quitte la boucle, sinon on repart pour un tour!
Plus de pâte?
On peut être amené à vouloir tester une condition une première fois avant d’entrer dans la boucle. Pour celà, nous disposons de la boucle «TANT QUE ... FAIRE».
TANT QUE j’ai encore de la pâte
DISPOSER une couche de pâtes
VERSER sauce tomate
VERSER sauce bechamelle
FIN TANT QUE
Dans cet exemple, si je n’ai plus de pâte à lasagne au frigo, je ne vais même pas commencer à faire mes lasagnes :) Ici, on n’a plus à faire à une condition de sortie mais une condition d’entrée. Il me reste de la pate?
La condition d’entrée est évaluée dès le début de la boucle, et si elle est FAUSSE, je ne rentre même pas dans la boucle. Si au contraire elle est vrai, le code de la boucle s’éxécute, puis, arrivé à la fin de la boucle, on remonte tester la condition d’entrée (pour savoir si l’on refait un tour ou pas.)
La boucle pour permet, à l’inverse des deux autres, d’effectuer le code un nombre défini de fois. Pour cela, il integre un compte tours. Ce compte-tour est une variable (de type «entier») qui, à chaque fin de tour, est «incrémentée» ou «décrémentée» (augmentée ou diminuée). Cette variable compte-tour est communément appelée i mais, comme c’est une variable, on peut lui donner le nom qu’on veut. Il faut en revanche ne pas oublier de la déclarer! Après avoir bien mangé, buvons...
POUR i DE 1 JUSQUA 10 FAIRE
BOIRE le verre i
FINPOUR
Quand j’entre dans la boucle, la variable compte-tours prends une valeur initiale (ici «1»).
La condition de sortie, «JUSQUA 10» est testée. Comme i = 1, i ≤ 10 , donc je boirais donc le «verre 1».
A la fin du tour, le compte-tours i est augmenté d’un 1 (1 + 1 = 2, désolé jean claude...).
On remonte évaluer la condition de sortie (et comme i =2, i ≤ 10 donc on referas un tour).
Arrivé à i = 10, on éxécute UNE DERNIERE FOIS la boucle. A la fin, de la boucle, on incrément i.
Maintenant que i vaut 11, la condition i ≤ 10 est FAUSSE (si si, 10 < 11...), on peut donc sortir de la boucle, la peau du ventre bien tendue...
Ce genre de boucle est l’un des plus employé en programmation, cependant il faut à tout prix connaitre le nombre de fois que l’on doit l’éxécuter.
Chaque boucle à son utilité, suivant que l’on connait ou non le nombre de tour que l’on va faire, et si l’on veut ou non faire à tout prix un premier tour dans la boucle. Petit mémo :
TANT QUE («TANT QUE ma poche n’est pas vide FAIRE ....»)
Je pioche des bonbons dans un sachet, en sachant que j’en veut au moins 1 :REPETER («REPETER ... TANT QUE j’en ai pas plein les dents»)
Je jete mes 20 CD de variété française des années 80 par la fenêtre :POUR («POUR cd_de_daube DE 1 JUSQUA 20 FAIRE....»)
Je ne suis pas borné à utiliser tester une seule condition dans mes boucles. Certains opérateurs booléens sont là pour regrouper le résultat de plusieurs conditions.
Exemple : «Tiens, il faut beau et j’ai de la viande... je me ferais bien un barbecue...»
SI temps = «beau» ET viande_dans_frigo = VRAI ALORS
SE FAIRE un barbecue
SINON
PASSER le weekend à ronchonner
FINSI
Il faut que les deux conditions soient remplies pour que je me fasse un barbecue.
Si UNE SEULE des deux n’est pas remplie ( soit je n’ai pas fait de course - viande_dans_frigo = FAUX - soit il pleut - temps ≠ «beau» )
alors je vais passer le weekend à ronchonner.
Exemple : « Si c’est pas toi ou lui, QUI M’A TAXÉ MES NACHOS?!»
SI tu_tapes_mes_nachos = VRAI OU il_taxe_mes_nachos = VRAI ALORS
TAPER toi
TAPER lui
SINON
APPELLER Scully et Mulder
FINSI
Il faut qu’AU MOINS UNE des conditions soit remplie pour que j’élucide le mystère du vol de nachos.
Si aucune n’est remplie, alors je ne m’en sortirais pas seul...
Grace à ces opérateurs complexe, on a accès à des conditions complexes qui permettent de traiter chaque cas.
TANT QUE match_foot ET (biere OU nachos) FAIRE
REGARDER la télé
FINTANT QUE
Tant qu’il y a le match à la télé (match_foot = VRAI) et que j’ai quelquechose à boire OU à manger, je regarde la télé.
Lorsque l’on veut associer une grosse quantité de valeurs d’un seul type à des variables, il existe plusieurs moyen.
Soit on crée une variable par valeur, soit on les regroupe par type dans des tableaux.
On peut imaginer les tableaux comme des un petit rangement à tiroirs, où chaque tiroir est numéroté. Pour déclarer un tableau, on lui donne un nom, on precise sa taille (le nombre de tiroirs/cases) et on indique le type de donnée qu’on va mettre dedans :
VAR
adresses : tableau[1...400] de chaine
notes : tableau[1...30] de réels
verification : tableau[1...4] de booléens
Pour remplir ou lire notre tableau, on considère chaque cas comme une variable :
// Il est possible de faire saisir le contenu
// de la case (ex : 3) par l’utilisateur
SAISIR adresses[3]
// ... ou l’entrer nous même
notes[4] ← 12,4
notes[2] ← 9,7
//On l’affiche comme une variable
AFFICHER adresses[8]
/* On utilise le contenu de la case. Ici, on lis le booléen contenu dans la case 3 du tableau «verification»
et on s’en sert comme condition dans un choix de type «SI» */
SI verification[3] = VRAI ALORS
AFFICHER «Ouh yeah»
FINSI
Les numéros des tirois sont appelés «indices» et ne peuvent être modifiés. Le «premier tiroir» sera toujours le «tiroir d’indice 1».
Exemple de représentation du tableau «notes» :
notes[3] = 17
notes[7] = Erreur /!\
Mon tableau n’a que 5 cases, il m’est donc difficile de lire la 7ème!
note[5] n’ayant pas été rempli (admettons) il ne contient rien (Ø).
Il faut faire attention car lorsqu’une case ne contient rien, et que l’on essaye d’en afficher le contenu, on peut obtenir tout et n’importe quoi!
L’accès au donnée se fait donc en sachant quelle cases sont remplies.
Pour afficher le contenu un tableau dont la taille est important, il peut être utile de passer par des boucles.
PROGRAMME affichage_contenu_de_tableau
VAR
notes : tableau[1 ... 300] de réels
i : entier
DEBUT
POUR i DE 1 JUSQUA 300 FAIRE
AFFICHER notes[i]
FINPOUR
FIN
À chaque tour de boucle, i va prendre une valeur de i à 300 (croissante) et je vais donc lire la case i de mon tableau.
Au premier tour, i vaut 1, donc notes[i] sera notes[1], et je vais afficher la première case de mon tableau notes, etc...
Lors du remplissage en revanche, je peux laisser l’utilisateur choisir de s’arreter ou non. Ce serait génant de le forcer a remplir les 300 cases d’un seul trait....
PROGRAMME remplissage_de_tableau
VAR
notes : tableau[1 ... 300] de réels
i : entier
continuer : chaine
DEBUT
i ← 1
continuer ← «oui»
TANT QUE continuer = « oui » ET i ≤ 300 FAIRE
AFFICHER «Veuillez entrer une note pour l’élève » , i
SAISIR notes[i]
AFFICHER «Souhaitez vous poursuivre?»
SAISIR continuer
FINTANT QUE
FIN
Au début de mon programme j’attribue à «continuer» la valeur «oui» car cette variable sera testée à chaque tour de la boucle.
De même, j’attribue à i (ma variable qui servira d’indice) la valeur 1 (pour commencer la saisie à la première case du tableau.
Dans ma boucle, je fais saisir la note de la case i de mon tableau «notes», puis je demande à l’utilisateur s’il souhaite continuer la saisie.
Retour à ma condition : l’utilisateur a bien tapé «oui» et i est bien en dessous de 300, je continue.
Dans tout cas contraire, je m’arrête et ne fais pas un autre tour de boucle.
Le principe s’applique également aux tableaux à plusieurs dimensions.
Pour déclarer un tableau multidimentionnel, on donne son nom, puis la taille de chacune des dimmension, et enfin le type du tableau.
Le code :
tournoi_golf[1...6][1...2] : de chaine
// tournoi_golf[lignes][colonnes]
déclare un tableau à deux dimensions, de 2 cases par 6 cases.
| Indice | Colonne 1 | Colonne 2 |
|---|---|---|
| 1 | Jean paul | SARTRES |
| 2 | Didier | ROUSSEAU |
| 3 | Alphonse | DAUDET |
| 4 | Robert | HUE |
| 5 | Pierre | PERRET |
| 6 | Ponce | PILATE |
Si je veux afficher le nom de la 3ème entrée et saisir le prénom de la 6ème entrée :
AFFICHER tournoi_golf[3][2] //Affiche "DAUDET"
tournoi_golf[6][1] ← «Albert»
Pour peupler et lire un tableau multidimensionnel, il faudra faire non pas une mais deux boucle :
l’une parcoure le tableau de haut en bas (lignes), et l’autre, lis les colonnes.
Pour ce faire nous aurons donc besoin de deux variables, en général i et j.
Exemple :
PROGRAMME lecture_de_tableau_multi
VAR
notes : tableau[1 ... 30][1...3] de réels
i,j : entier
DEBUT
POUR i DE 1 JUSQUA 30 FAIRE
POUR j DE 1 JUSQUA 3 FAIRE
AFFICHER notes[i][j]
FINPOUR
FINPOUR
FIN
Les tableaux savent «stocker» des données, mais ces données doivent être de même type.
Il est cependant possible de définir un type, dit enregistrement, permettant de structurer plusieurs types differents de données.
Pour pouvoir utiliser un enregistrement, il faut le déclarer dans une section particulière du programme appellée «TYPE».
Ensuite, on peut attribuer à une variable ce nouveau type, ou encore l’utiliser dans un tableau.
On doit donner son nom, ainsi que le nom et le type de chacun des éléments qui le compose.
Déclarons par exemple un type «produit» qui contiendra le nom, le prix et sa description.
On peut ensuite créer une variable de type «produit» et un tableau de «produit» :
PROGRAMME mon_algo
TYPE
STRUCTURE produit
nom : chaîne
prix : réel
description : chaîne
FINSTRUCT
VAR
exemplaire : produit
liste_produits : tableau[1...300] de produit
Pour stocker dans ma variable exemplaire des détails, il me suffit d’ajouter, séparé par un point, le nom du champ dans lequel je veux mettre les données :
exemplaire.nom ← «huitre»
exemplaire.prix ← 12,50
exemplaire.description ← «Un met raffiné pour qui à l’estomac bien accroché»
Il en va de même pour mon tableau liste_produit. Je dois en revanche préciser à quelle case de liste_produit je me rapporte :
L’avantage de ce type de structure est qu’il permet de stocker tout un tas de valeurs hétéroclites se rapportant à un seul élément.
Dans un tableau, seul cet élément est indicé, et il est ainsi plus aisé de lire le champ voulu de cet élément.
En partant sur notre exemple de déclaration d’un tableau de produit, nous allons maintenant afficher son contenu :
AFFICHER «Indice Contenu»
AFFICHER «i nom prix description»
POUR i DE 1 JUSQUA 300 FAIRE
AFFICHER i ,
liste_produit[i].nom ,
liste_produit[i].prix ,
liste_produit[i].description ,
liste_produit[i].description
FINPOUR
Voilà ce qui devrait s’afficher à l’écran de l’utilisateur :
| Indice | Contenu | ||
|---|---|---|---|
| nom | prix | description | |
| 1 | kebab | 6 | Trop d’kebab tue l’kebab... |
| 2 | huitre | 12,50 | Un met raffiné pour qui à l’estomac bien accroché |