7ute

Portfolio

Qui suis-je?

Qui suis-je? À Propos
- Je suis un passionné d'informatique de 28 ans,
- vivant sur la Côte d'Azur,
- amateur de bon wiskey,
- développeur et webdesigner à mon compte,
- convertisseur naturel de café en code,
- fan de musique assez peu connues,
- et musicien à mes heures perdues.
Que fais-je? Mes compétences
- Code : HTML &co. ( XHTML, DHTML, CSS ), PHP, Javascript (framework jQuery, JSON ), C / C++, Objective-C, BASIC, Action Script,
- OS : Mac Os 7.X à X.7, Windows 5 (XP) à 8, Ubuntu &co., iOS,
- Outils : Adobe CS (Photoshop, Illustrator, Flash), Coda, Transmit,

Contact

Pers. / Pro. Julien CAUVIN Pour toute demande de création de site / progiciel
Attention, antispam ultra complexe de type "si tu spam, j'crame ta caisse"!

Blog

Aucune note pour l'instant. Repassez plus tard!

Cours

Sommaire Algorithme
Ces pages sont là pour fournir une aide de révision de l'algorithme.
- Variables, constantes et déclarations
- Structure d'un Programme
- Saisie / Affichage
- Structures Conditionnelles
- Choix conditionnels
- Choix conditionnel "Si"
- Choix conditionnel "Selon"
- Boucles conditionnelles
- Boucle "Faire ... Répéter Tant Que"
- Boucle "Tant Que ... Faire"
- Boucle "Pour"
- Operateurs Booléens
- Tableaux
- Parcours d'un tableau
- Tableau multi-dimensionnel
- Enregistrements
- Sous-Programmes
- Paramètres et retours
- Variables locales
- Imbrications
- Récurrence
- Fichiers
Variables Algorithme

Variables

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 ← «Aye coquine » , « ça farte?»
La variable variable toto contient désormais la chaîne «Aye coquine ça farte?».
BOOLEEN : VRAI ou FAUX (et rien d’autre ;) ). Il nous sera très utile mais nous verrons mieux son fonctionnement lors de l’étude des structures de contrôle.

Constantes

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.

Déclarations

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

↑ Twitter Facebook
Structure d'un programme Algorithme

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.
Il a un nom (de préférence en rapport avec son action), ici «nom_du_programme».
Si l’on ne fait pas de declaration de variables ou de constantes, les mots clefs «VAR» et «CONST» peuvent être omis.

Le code sur une ligne précédée de // ou encadré de /* et */ ne sera pas éxécuté. Ce sont des commentaires.
Entre les mots clef «DEBUT» et «FIN», nous pourrons effectuer toutes nos opérations.

↑ Twitter Facebook
Saisie / Affichage Algorithme

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»

↑ Twitter Facebook
Structures conditionnelles Algorithme
Les structures conditionnelles permettent d’aiguiller le programme. Grace à elles nous pouvons choisisr d’executer telle ou telle partie de code, ou encore d’effectuer la même action un bon nombre de fois.

Choix conditionnels
On peut choisir d’effectuer ou non une partie du code grace à une boucle conditionnelle. Il en existe de deux sortes.

Choix conditionnel «si»
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.
Le mot clef «SINON» et le code qui suit peuvent être omis. Dans ce cas, si la condition est fausse,le programme continueras directement apres le «FINSI» La condition est de type booléenne. Nous avons vus que les variables booléennes permettent de stocker VRAI ou FAUX, donc ce code («bouboule» étant un booléen) :
SI bouboule = VRAI ALORS
AFFICHER «Cette variable est évaluée à VRAI»
FINSI Peut aussi s’ecrire :
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.
Choix conditionnel «selon»
Parfois, il est necessaire d’imbriquer plusieurs boucles «SI» pour définir l’action à effectuer. 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».
Les boucles
Il peut être parfois necessaire d’effectuer plusieurs fois la même tâche. Pour celà, en algo, nous disposons de structure permettant d’effectuer plusieurs fois le même morceau de code. Ces structure ont en commun une «condition d’éxécution» de la boucle.
Cette dernière doit IMPERATIVEMENT être testée avec tous les cas pour une simple et bonne raison : si on ne sort pas de la boucle, le programme effectuera infiniment le code de celle-ci, entrainant un plantage. Pour comprendre la boucle, rien de mieux que les lasagnes :D Vous cuisinez? Si oui, alors vous avez peut être fait des «boucles» sans le vouloir.... 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?
- VRAI, je n’ai plus de pâte > je sors du programme.
- FAUX, il m’en reste > je fais mes lasagnes
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?
- VRAI, (et j’ai faim) > je fais mes lasagnes.
- FAUX > je sors du programme
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.)
Boucle «Pour»
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.
Petit topo
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 :
- Je compte le nombre de pièces que j’ai dans ma poche en les sortant une à une : 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....»)
↑ Twitter Facebook
Opérateurs Booléens Algorithme

Je ne suis pas borné à utiliser tester une seule condition dans mes boucles. Certains opérateurs booléens sont là pour regroupper le résultat de plusieurs conditions.
Opérateur ET
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.
Opérateur OU
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é.

↑ Twitter Facebook

Tableaux Algorithme

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» (en algo! dans d’autre langage les tableau commencent à 0, mais c’est une autre histoire).
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.

Parcours d’un tableau

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’arrete et ne fais pas un autre tour de boucle.

Tableaux multi-dimentionnels

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

Enregistrements Algorithme

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
AFFICHER liste_produit[i].nom
AFFICHER liste_produit[i].prix
AFFICHER 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é

Portfolio

Qui suis-je?

Qui suis-je? À Propos

Que fais-je? Mes compétences

Contact

Pers. / Pro. Julien CAUVIN Pour toute demande de création de site / progiciel

Blog

Aucune note pour l'instant. Repassez plus tard!

Cours

Sommaire Algorithme

Variables Algorithme

Variables

Constantes

Déclarations

Structure d'un programme Algorithme

Saisie / Affichage Algorithme

Structures conditionnelles Algorithme

Choix conditionnels

Choix conditionnel «si»

Choix conditionnel «selon»

Les boucles

Boucle «Pour»

Petit topo

Opérateurs Booléens Algorithme

Opérateur ET

Opérateur OU

Tableaux Algorithme

Parcours d’un tableau

Tableaux multi-dimentionnels

Enregistrements Algorithme

Musique