Cours Algorithmique 3

ALGORITHME
Définition
nom masculin (d'Al-Khârezmi, médecin arabe).
Suite de raisonnements ou d'opérations qui fournit la
solution de certains problèmes.
Objectifs
Un algorithme sert à transmettre un savoir faire.
Il décrit les étapes à suivre pour réaliser un travail.
Il permet d'expliciter clairement les idées de solution
d'un problème indépendamment d'un langage de
programmation.
L'utilisateur d'un algorithme n'aura qu'à suivre toutes
les instructions, dans l'ordre pour arriver au résultat
que doit donner l'algorithme.
1
Algorithme
Le "langage algorithmique" que nous utilisons est un
compromis entre un langage naturel et un langage de
programmation.
Nous présentons les algorithmes comme une suite

d'instructions dans l'ordre des traitements. Ils sont toujours
accompagnés d'un lexique qui indique, pour chaque
variable, son type et son rôle.
Nous manipulerons les types couramment rencontrés

dans les langages de programmation : entier, réel,
booléen, caractère, chaîne, tableau et type composite. ß
Formalisme
Un algorithme doit être lisible et compréhensible par plusieurs
personnes.
Il doit donc suivre des règles. Il est composé d'une entête et d'un
corps.
L'entête comprend :
- Nom : le nom de l'algorithme

- Rôle : ce que fait l'algorithme
- Données : les données fournies à l'algorithme
- Résultat : ce que l'on obtient à la fin du traitement
- Principe : le principe utilisé dans l'algorithme
Le corps :
- il est délimité par les mots clés début et fin.

3
- il se termine par un lexique, décrivant les variables utilisées
Formalisme
Par convention, tous les identifiants de variables seront
notés en minuscule et auront un nom mnémonique
Il en va de même pour les fonctions, dont l'identifiant

doit être le plus explicite sur son rôle. Ce dernier peut être
une contraction de plusieurs mots, par
conséquent pour rendre la lecture plus facile, la
première lettre de chaque mot est mis en majuscule
(exemple : CalculerAireRectangle).
m
Formalisme
Exemple d'algorithme :
Nom : AddDeuxEntiers.
Rôle : additionner deux entier et mémoriser le résultat
Données : les valeurs à additionner.
Résultat : la somme des deux valeurs.
Principe : Additionner deux entiers a et b et mettre le résultat dans
c.
début
cĸa+b
fin
Lexique :
a : entier ý
b : entier
c : entier
Les variables
Une variable est une entité qui contient une information, elle
possède :
un nom, on parle d¶identifiant
une valeur
un type qui caractérise l¶ensemble des valeurs que peut

prendre la variable
L¶ensemble des variables est stocké dans la mémoire de

l¶ordinateur

Les variables
Type de variable
entier pour manipuler des entiers
réel pour manipuler des nombres réels
booléen pour manipuler des valeurs booléennes
caractère pour manipuler des caractères alphabétiques

et numériques
â
chaîne pour manipuler des chaînes de caractères
permettant de représenter des mots ou des phrases.
Les variables
A un type donné, correspond un ensemble d'opérations
définies pour ce type.
Une variable est l'association d'un nom avec un type,

permettant de mémoriser une valeur de ce type.
ù
Opérateur, opérande et expression
Un R érateur est un symbole d¶opération qui permet d¶agir
sur des variables ou de faire des ³calculs´
Une R érande est une entité (variable, constante ou

expression) utilisée par un opérateur
Une ex ressiRn est une combinaison d¶opérateur(s) et

d¶opérande(s), elle est évaluée durant l¶exécution de
l¶algorithme, et possède une valeur (son interprétation) et un
type
]
Opérateur, opérande et expression
Exemple dans a + b :
a est l¶opérande gauche
+ est l¶opérateur
b est l¶opérande droite
a + b est appelé une expression
Si par exemple a vaut ß et b 3, l¶expression a + b vaut ý
Si par exemple a et b sont des entiers, l¶expression a + b est un

entier
10
Les opérateurs
Un opérateur peut être unaire ou binaire :
Vnaire s¶il n¶admet qu¶une seule opérande, par exemple
l¶opérateur non
§inaire s¶il admet deux opérandes, par exemple
l¶opérateur +
Un opérateur est associé à j type de donnée et ne peut être

utilisé qu¶avec des variables, des constantes, ou des
expressions de type
Par exemple l¶opérateur + ne peut être utilisé qu¶avec les

types arithmétiques (naturel, entier et réel) ou (exclusif) le
11
type chaîne de caractères
Les opérateurs
mn ne eut as additiRnner un entier et un caractère
Toutefois
dans certains cas on accepte
d¶utiliser un opérateur avec deux opérandes de types
différents, c¶est par exemple le cas avec les types
arithmétiques (ß + 3.ý)
La signification d¶un opérateur peut changer en fonction

du type des opérandes
l¶opérateur + avec des entiers aura pour sens l¶addition,
ß+3 vaut ý
avec des chaînes de caractères il aura pour sens la
cRncaténatiRn "bonjour" + " tout le monde" vaut 1ß
"bonjour tout le monde"
Les opérateurs booléens
Pour les booléens nous avons les opérateurs non, et, ou, ouExclusif
Non
Et
13
Ou
Ou exclusif
1m
Rappels sur la logique booléenne...

Valeurs possibles : Vrai ou Faux
Associativité des opérateurs et et ou

a et (b et c) = (a et b) et c
Commutativité des opérateurs et et ou

a et b = b et a
a ou b = b ou a
1ý
Distributivité des opérateurs et et ou
a ou (b et c) = (a ou b) et (a ou c)
a et (b ou c) = (a et b) ou (a et c)
Involution (homographie réciproque)

(homos semblable et graphein écrire)
non non a = a
Loi de Morgan
non (a ou b) = non a et non b
non (a et b) = non a ou non b 1
Les opérateurs sur les numériques
On retrouve tout naturellemment +, -, *, /

Avec en plus pour les entiers div et mod, qui permettent
respectivement de calculer une division entière et le
reste de cette division,
par exemple :
11 div ß vaut ý
11 mod ß vaut 1
1â
Les opérateurs sur les numériques
L¶opérateur d¶égalité :
C¶est l¶opérateur que l¶on retrouve chez tous les types
simples qui permet de savoir si les deux opérandes sont
égales
Il est représenté par le caractère =
Le résultat d'une expression contenant cet opérateur est un
booléen
On a aussi l¶opérateur d¶inégalité :
Et pour les types possédant un ordre les opérateurs de

comparaison
1ù
<, , >,
Priorités des opérateurs
Tout comme en arithmétique les opérateurs ont des
priorités
Par exemple * et / sont prioritaires sur + et -
Pour les booléens, la priorité des opérateurs est non, et,
ouExclusif et ou
Pour clarifier les choses (ou pour dans certains cas

supprimer toutes ambiguïtés) on peut utiliser des
parenthèses
1]
Manipulation de variables
On ne peut faire que deux choses avec une variable :
1. Obtenir son contenu
Cela s¶effectue simplement en nommant la variable
ß. Affecter un (nouveau) contenu

Cela s¶effectue en utilisant l¶opérateur d¶affectation
représenter par le symbole ĸ
La syntaxe de cet opérateur est : ß0

identifiant de la variable ĸ expression
Manipulation de variables
Par exemple l¶expression c ĸ a + b se comprend de la
façon suivante :
On prend la valeur contenue dans la variable a
On prend la valeur contenue dans la variable b
On additionne ces deux valeurs
On met ce résultat dans la variable c
Si c avait auparavant une valeur, cette dernière est perdue !

ß1
Les entrées / sorties
Un algorithme peut avoir des interactions avec l¶utilisateur
Il peut afficher un résultat (du texte ou le contenu d¶une

variable)
demander à l¶utilisateur de saisir une information afin

de la stocker dans une variable
En tant qu¶informaticien on raisonne en se mettant la ßß

lace de la machine´, donc :
Instruction d'écriture
L'instruction de restitution de résultats sur le périphérique de
sortie (en général l'écran) est :
écrire(liste d'expressions)
Cette instruction réalise simplement l'affichage des valeurs

des expressions décrites dans la liste.
Ces instructions peuvent être simplement des variables ayant
des valeurs ou même des nombres ou des commentaires écrits
sous forme de chaînes de caractères.
Exemple d'utilisation : écrire(x, y+ß, "bonjour") ß3

Instructions de lecture
L'instruction de prise de données sur le périphérique d'entrée
(en général le clavier) est :
variable <- lire()
L'exécution de cette instruction consiste à affecter une valeur

à la variable en prenant cette valeur sur le périphérique
d'entrée.
Avant l'exécution de cette instruction, la variable avait ou ßm

n'avait pas de valeur. Après, elle a la valeur prise sur le
périphérique d'entrée.
Exemple
On désire écrire un algorithme qui lit sur l'entrée standard une valeur
représentant une somme d'argent et qui calcule et affiche le nombre de billets de
100 Euros, ý0 Euros et 10 Euros, et de pièces de ß Euros et 1 Euro qu'elle
représente.
Nom : DécompSomme.
Rôle : Décomposition d'une somme
Données : la somme à décomposée.
Résultat : les nombres de billets et de pièces.
Principe : on commence par lire sur l'entrée standard l'entier qui représente la
somme d'argent et affecte la valeur à
une variable somme.
Pour obtenir la décomposition en nombre de billets
et de pièces de la somme d'argent, on procède par
ßý
divisions successives en conservant chaque fois le reste.
début
somme <- lire()
billet100 <- somme div 100
reste100 <- somme mod 100
billetý0 <- reste100 div ý0;
resteý0 <- reste100 mod ý0
billet10 <- resteý0 div 10
reste10 <- resteý0 mod 10
pieceß <- reste10 div ß
resteß <- reste10 mod ß
piece1 <- resteß
écrire (billet100, billetý0, billet10, pieceß, piece1)
ß
fin
Lexique
- somme : entier, la somme d'argent à décomposer
- billet100 : entier, le nombre de billets de 100 Euros
- billetý0 : entier, le nombre de billets de ý0 Euros
- billet10 : entier, le nombre de billets de 10 Euros
- pieceß : entier, le nombre de pièces de ß Euros
- piece1 : entier, le nombre de pièces de 1 Euro
- reste100 : entier, reste de la division entière de
somme par 100
- resteý0 : entier, reste de la division entière de
reste100 par ý0
- reste10 : entier, reste de la division entière de resteý0 ßâ
par 10
- resteß : entier, reste de la division entière de reste10 par ß
Instruction conditionnelle
L¶instruction si alors sinon permet de conditionner
l¶exécution d¶un algorithme à la valeur d¶une expression
booléenne. Syntaxe :
si alRrs
j j j
sinRn
j j j
j
finsi ßù
La deuxième partie de l¶instruction est optionnelle, on peut
avoir la syntaxe suivante :
si alRrs
j j j
finsi
ß]
Exemple
Nom : ValeurAbs
Rôle : Calcule la valeur absolue d¶un entier
Données : La valeur à calculer
Résultat : La valeur Absolue
Principe : Si valeur < 0, on la multiplie par -1
début
si valeur 0 alors
valeur absolue ĸ valeur
sinon
valeur absolue ĸ valeur * -1
finsi
fin
Lexique
30
- valeur : entier, la valeur à tester
- valeurabsolue : la valeur absolue
L'instruction cas
Lorsque l¶on doit comparer une même variable avec plusieurs
valeurs, comme par exemple :
si a=1 alRrs
faire une chose
sinRn
si a=ß alRrs
faire une autre chose
sinRn
si a=m alRrs
faire une autre chose
sinRn
...
finsi
finsi
finsi
31
On peut remplacer cette suite de si par l¶instruction cas
L'instruction cas
Sa syntaxe est :
cas R v vaut
v1 : action1
vß : actionß
...
: actionn
j: action autre
fincas
v1,. . . ,vn sont des cRnstantes de type scalaire (entier, naturel,

enuméré, ou caractère)
action i est exécutée si v = vi (on quitte ensuite l¶instruction cas)
3ß
jest exécutée si quelque soit i, v vi
Les itérations
Il arrive souvent dans un algorithme qu'une même action soit
répétée plusieurs fois, avec éventuellement quelques variantes.
Il est alors fastidieux d'écrire un algorithme qui contient de
nombreuses fois la même instruction. De plus, ce nombre peut
dépendre du déroulement de l'algorithme.
Il est alors impossible de savoir à l'avance combien de fois la
même instruction doit être décrite.
Pour gérer ces cas, on fait appel à des instructions en boucle qui
ont pour effet de répéter plusieurs fois une même instruction.
Deux formes existent : la première, si le nombre de répétitions
est connu avant l'exécution de l'instruction de répétition, la
seconde s'il n'est pas connu. L'exécution de la liste des
instructions se nomme itération.
33
Répétitions inconditionnelles
Il est fréquent que le nombre de répétitions soit connu à
l'avance, et que l'on ait besoin d'utiliser le numéro de l'itération
afin d'effectuer des calculs ou des tests. Le mécanisme
permettant cela est la boucle Pour.
Forme de la boucle Pour :
Pour variable de valeur initiale à valeur finale faire

liste d'instructions
fpour 3m
La variable dont on donne le nom va prendre
successivement toutes les valeurs entières entre valeur
initiale et valeur finale. Pour chaque valeur prise par la
variable, la liste des instructions est exécutée.
La valeur utilisée pour énumérer les itérations est appelée

valeur d'itération, indice d'itération ou compteur.
L'incrémentation par 1 de la variable est implicite.
3ý
Autre forme de la boucle Pour :
Pour variable décroissante de valeur initiale à valeur finale

faire
fpour
La variable d'itération est décrémentée de 1 après chaque

itération.
3
Les répétitions conditionnelles
L'utilisation d'une "boucle pour" nécessite de connaître à
l'avance le nombre d'itérations désiré, c'est-à-dire la valeur
finale du compteur. Dans beaucoup de cas, on souhaite
répéter une instruction tant qu'une certaine condition est
remplie, alors qu'il est à priori impossible de savoir à l'avance
au bout de combien d'itérations cette condition cessera d'être
satisfaite. Dans ce cas, on a deux possibilités :
- la boucle Tant que
- la boucle Répéter jusqu'à
Syntaxe de la boucle Tant que :

tant que condition faire
ftant
3â
Cette instruction a une condition de poursuite dont la valeur
est de type booléen et une liste d'instructions qui est répétée
si la valeur de la condition de poursuite est vraie : la liste
d'instructions est répétée autant de fois que la condition de
poursuite a la valeur vraie. Le déroulement pas à pas de cette
instruction
équivaut à :
si condition
alors liste d'instructions
si condition
alors liste d'instructions
si condition
alors liste d'instructions 3ù
...
Etant donné que la condition est évaluée avant l'exécution des
instructions à répéter, il est possible que celles-ci ne soient
jamais exécutées.
Il faut que la liste des instructions ait une incidence sur la

condition afin qu'elle puisse être évaluée à faux et que la
boucle se termine.
Il faut toujours s'assurer que la condition devient fausse au

bout d'un temps fini.
Exemple

Un utilisateur peut construire des rectangles de taille

3]
quelconque, à condition que les largeurs qu'il saisit soient
supérieures à 1 pixel.
Nom : saisirLargeurRectangle
Rôle : Vérification validité largeur saisie
Données : La largeur
Résultat :
Principe : Tant que la largeur est < 1, on demande de resaisir la largeur
début
écrire ("indiquez la largeur du rectangle :")
largeur <- lire()
tant que largeur < 1 faire
écrire ("erreur : indiquez une valeur strictement positive")
largeur <- lire()
ftant
fin
m0
Lexique
- largeur : entier, largeur courante saisie
Syntaxe de la boucle Répéter jusqu'à :
Répéter
jusqu'à condition
La séquence d'instructions est exécutée au moins une fois et

jusqu'à ce que l'expression soit vraie. Dès que la condition
est vrai, la répétitivité s'arrête.
m1
Nom : saisirLargeurRectangle
Rôle : Vérification validité largeur saisie
Données : La largeur
Résultat :
Principe : Tant que la largeur est < 1, on demande de resaisir la largeur
début
Répéter
largeur <- lire()
si largeur < 1 alors
écrire ("erreur : indiquez une valeur strictement positive")
fin si
jusqu'à largeur >= 1
fin
Lexique mß
- largeur : entier, largeur courante saisie
Différences entre les boucles Tant que et Répéter jusqu'à :

- la séquence d'instructions est exécuter au moins une fois dans la
boucle Répéter jusqu'à, alors qu'elle peut ne pas être exécuter
dans le cas du Tant que.
- la séquence d'instructions est exécuter si la condition est vrai

pour le Tant que et si la condition est fausse pour le Répéter
jusqu'à.
- Dans les deux cas, la séquence d'instructions doit

nécessairement faire évoluer la condition, faute de quoi on m3
obtient une boucle infinie.
Chaînes de caractères
Le type chaîne permet de décrire des objets
formés par la juxtaposition de plusieurs
caractères. Dans la plupart des langages de
programmation, il existe des "outils" pour les
manipuler. Au niveau des algorithmes, nous
introduisons quelques fonctions prédéfinies
qui correspondent aux "outils" classiquement
fournis par les langages. Cette liste partielle
peut bien sûr être complétée en fonction de
vos besoins.
ß

fonction concat(ch1:chaîne, ch2:chaîne):chaîne
retourne une chaîne formée par la concaténation de O et de O . La chaîne

résultat est formée de O suivi de O .
?

fonction longueur(ch:chaîne):entier
retourne la longueur de la chaîne O c'est-à-dire le nombre de caractères dont elle

est constituée.
K

fonction sousChaîne(ch:chaîne, i:entier, l:entier):chaîne
retourne une sous-chaîne de longueur extraite de la chaîne O , à la position .
exemple : sousChaîne("informatique"", 6, 2) retourne la chaîne "ma".

p
fonction ième(ch:chaîne, i:entier):caractère
retourne le ième caractère de la chaîne O .
a

fonction remplace(ch InOut:chaîne, i:entier, c:caractère)
remplace le ième caractère de la chaîne O par la

caractère O.

!"


#

$%

$% !

&
'
!

$%
! !"
$% "

$% !

!

( ) % )

%
)

%
)
Les tableaux
Lorsque les données sont nombreuses et de même type,
afin d'éviter de multiplier le nombre des variables, on les
regroupe dans un tableau
Le type d'un tableau précise le type (commun) de tous les

éléments.
Syntaxe :
tableau type_des_éléments[borne_inf ... borne_sup]
En général, nous choisirons toujours la valeur 0 pour la

borne inférieure dans le but de faciliter la traduction de
l'algorithme vers les autres langages (C, Java, ...). Pour un
tableau de 10 entiers, on aura : mm
tab : tableau entier[0..]]
Les tableaux
Les tableaux à une dimension ou vecteurs
0 1 ß 3 m ý â ù ]
mý ým 1 -ý ßß 13m m] 1ß ]0 -ß
Ce tableau est de longueur 10, car il contient 10

emplacements.
Chacun des dix nombres du tableau est repéré par son rang,
appelé indice
Pour accéder à un élément du tableau, il suffit de préciser

entre crochets l'indice de la case contenant cet élément.
Pour accéder au ýème élément (ßß), on écrit : Tab[m] mý
Les tableaux
Les instructions de lecture, écriture et affectation s'appliquent
aux tableaux comme aux variables.
x ĸ Tab[0]
La variable x prend la valeur du premier élément du tableau,

c'est à dire : mý
Tab[] ĸ m3
Cette instruction a modifiée le contenu du tableau

m
Les tableaux
Parcours complet d'un tableau
La plupart des algorithmes basés sur les tableaux utilisent des

itérations permettant de faire un parcours complet ou partiel
des différents éléments du tableau. De tels algorithmes
établissent le résultat recherché par récurrence en fonction des
éléments successivement rencontrés.
Les répétitions inconditionnelles sont le moyen le plus simple

de parcourir complètement un tableau.
mâ
Les tableaux
Dans l'exemple suivant, le programme initialise un à un tous les éléments
d'un tableau de n éléments :
InitTableau
début
pour i de 0 à n-1 faire
tab[i] ĸ 0
fpour
fin
Lexique :
- i : entier, indice d'itération
- n : entier, taille du tableau
- tab : tableau entier[0..n-1]
mù
Les tableaux
Les tableaux à deux dimensions ou matrices
Lorsque les données sont nombreuses et de même nature, mais

dépendent de deux critères différents, elles sont rangées dans un
tableau à deux entrées.
0 1 ß 3 m ý
0 1ß ßù mm ß â ââ 3ß
1 ß3 3 ý1 11 3ù ým ßý
ß m3 ß1 ýý â ù3 m1 ]
Ce tableau a 3 lignes et â colonnes. Les éléments du tableau sont
repérés par leur numéro de ligne et leur numéro de colonne.
m]
Tab[1, m] = 3ù
Les tableaux
La variable T[L, C] s'appelle l'élément d'indice L et C du
tableau T.
T[0 T[0, T[0, T[0, T[0, m]
, 0] 1] ß] 3]
T[1 T[1, T[1, T[1, T[1, m]

, 0] 1] ß] 3]
T[ß T[ß, T[ß, T[ß, T[ß, m]
, 0] 1] ß] 3]
Tableau T à 3 lignes et ý colonnes.
Les tableaux peuvent avoir n dimensions.

ý0
Les procédures et les fonctions
La méthodologie de base de l¶informatique est :
Y Abstraire
Retarder le plus longtemps possible l¶instant du
codage
2 DécRm Rser
"...diviser chacune des difficultés que j¶examinerai en
autant de parties qu¶il se pourrait et qu¶il serait requis
pour les mieux résoudre." Descartes
3 CRmbiner
Résoudre le problème par combinaison d¶abstractions ý1
Par exemple, résoudre le problème suivant :
Ecrire un programme qui affiche en ordre croissant les notes
d¶une promotion suivies de la note la plus faible, de la note la
plus élevée et de la moyenne, revient à résoudre les problèmes
suivants :
- Remplir un tableau de naturels avec des notes saisies
par l¶utilisateur
- Afficher un tableau de naturels
- Trier un tableau de naturel en ordre croissant
- Trouver le plus petit naturel d¶un tableau
- Trouver le plus grand naturel d¶un tableau
- Calculer la moyenne d¶un tableau de naturels
ýß<
Chacun de ces sous-problèmes devient un nouveau problème à
résoudre.
Si on considère que l¶on sait résoudre ces sous-problèmes, alors on

sait ³quasiment´ résoudre le problème initial.
Donc écrire un programme qui résout un problème revient toujours

à écrire des sous-programmes qui résolvent des sous parties du
problème initial.
En algorithmique il existe deux types de sous-programmes :

- Les fonctions
- Les procédures
ý3
Procédure
V

*
+
,

(

-
(

-.#()

*

(

-.#/)

*

0

12

3
% *
)
4/53V/ .#(
-
-6
.#/
-
-!

*
3V
1

71&
(*

+

4

)
** 8*9*:!;
#

-.#/ *

+

-.#( * *
4/53V/< .#(5#/
.#(& 1/
ý3
.#/ #(#V5#/ =>#?5#/@!
& 1/;
3V
Passage de paramètre
Ò
Lorsque nous souhaitons que la valeur d¶une variable du programme appelant ne soit pas modifiée, elle devra alors être passée par valeur.
La procédure ou la fonction qui la manipule recevra cette valeur en entrée du programme mais il s¶agira de la copie en mémoire de la valeur de la variable
d¶origine. Dans notre pseudo, le passage par valeur est indiqué par le mot clé *
Ò
Lorsque nous utilisons le passage d¶une valeur par référence, nous indiquons non sa valeur mais la référence en mémoire de celle-ci. Ainsi, la procédure ou
fonction manipule donc le même espace de mémoire. Toute modification apportée à la variable manipulée par la fonction ou procédure touchera donc la
variable d¶origine. Attention donc au choix effectué lors de la transmission des paramètres à une procédure !
Dans notre pseudo, le passage par référence est indiqué par le mot clé *
ý3
Fonction
Vne
est une procédure dont le but est de déterminer une valeur et de la retourner au programme appelant.
Dans notre pseudo-langage, elle se déclare de la manière suivante :

.#(
-
-.#/
-
-!)

*
3V

/ V/&*
71&
Les mêmes remarques que pour la procédure s'appliquent.

De plus, il faut noter que la fonction retourne une valeur et que donc à la déclaration on doit indiquer son type, c'est à dire le type de cette valeur.
L'appel d'une fonction s'écrit :

variable $%% nom de la fonction valeur1 , valeur2 , .... !;
Vne fonction ne peut donc pas retourner un tableau.
Exemple:
FONCTION valeur_absolue (VAL ENTIER nombre): ENTIER
DEBVT
SI (nombre < 0)
ALORS
RETOVRNE (nombre * (-1))
SINON
RETOVRNE nombre
FSI
FIN
Elle est utilisée ainsi :
i <-- valeur_absolue(i);
limite <-- valeur_absolue(-120);
ý3
Portée des variables
L¶introduction des fonctions et procédures nous permet d¶aborder un nouvel aspect de la programmation, celui de la portée des variables.
Lorsqu¶une variable est déclarée à l¶intérieur d¶une fonction ou procédure, elle est dite car elle n¶est accessible qu¶à l¶intérieur de la fonction ou de
la procédure et sa durée de vie se limite le plus souvent à celle-ci.
Ainsi, vous ne pouvez faire référence et manipuler une variable locale en dehors de la fonction ou de la procédure où a été déclarée celle-ci.

Par extension, une variable déclarée dans l¶entête du programme sera déclarée , car accessible depuis l¶ensemble du programme et sa durée de
vie, celle du temps d¶exécution du programme.

O O O

O
O O
O O
O
O
O
O O

ý3
Les fonctions récursives
Une fonction récursive est une fonction qui pour fournir un
résultat, s¶appelle elle-même un certain nombre de fois.
Exemple : la formule de calcul de la factorielle d¶un nombre n

s¶écrit :
n!=1xßx3x«xn
Ce qui peut se programmer avec une boucle Pour.
ým
Une autre manière de voir les choses, serait de dire que :
n ! = n x (n-1) !
D¶où, la factorielle d¶un nombre, c¶est ce nombre multiplié

par la factorielle du nombre précédent.
Pour programmer cela, il faut une fonction Facto, chargée de

calculer la factorielle. Cette fonction effectue la
multiplication du nombre passé en argument par la
factorielle du nombre précédent.
Et cette factorielle du nombre précédent va bien entendu être
elle-même calculée par la fonction Fact. ýý
Pour terminer, il nous manque la condition d'arrêt de ces
auto-appels de la fonction Facto.
Dans le cas d'un calcul de factorielle, on s¶arrête quand on
arrive au nombre 1, pour lequel la factorielle est par
définition 1.
Fonction Facto (n : Entier)

Début
Si n = 1 alors
Renvoyer 1
Sinon
Renvoyer Facto(n - 1) * n
Finsi ý
Fin
Le processus récursif remplace en quelque sorte la boucle,
c¶est-à-dire un processus itératif.
Il est à noter que l'on traite le problème à l¶envers : on part

du nombre, et on remonte à rebours jusqu¶à 1, pour
pouvoir calculer la factorielle.
Cet effet de rebours est caractéristique de la

programmation récursive.
ýâ
Pour conclure sur la récursivité, trois remarques fondamentales.
- la programmation récursive, pour traiter certains
problèmes, peut être très économique, elle permet de faire
les choses correctement, en très peu de lignes de
programmation.
- en revanche, elle est très dispendieuse de ressources

machine. Car il faut créer autant de variable temporaires
que de " tours " de fonction en attente.
- toute fonction récursives peut également être formulée

en termes itératifs ! Donc, si elles facilitent la vie du ýù
programmeur, elle ne sont pas indispensable.
Les algorithmes de tri
Les algorithmes de tri, sont utilisés principalement pour
les tableaux et les listes, ils peuvent aller du plus simple
au plus compliquer.
Le tri à bulle
C¶est un des algorithmes le plus connu. Bien qu¶il soit
rarement efficace en terme de temps de calcul, il est
néanmoins correcte.
Le principe consiste à balayer tout le tableau, en

comparant les éléments adjacents et en les échangeant
s¶ils ne sont pas dans le bon ordre. ý]
Un seul passage ne déplacera un élément donné que
d¶une position, mais en répétant le processus jusqu¶à ce
que plus aucun échange ne soit nécessaire, le tri sera
effectué.
Ce tri va nécessiter un grand nombre de déplacements

d¶éléments, il est donc inutilisable dans les cas où ces
déplacements sont coûteux en temps.
Il peut par contre être intéressant quand le tableau initial

est pré-trié, les éléments n¶étant pas disposés trop loin de
leur position finale, par exemple lors d¶un classement
alphabétique, où les éléments sont déjà triés par leur 0
première lettre.
Le tri par insertion
Plutôt que de déplacer les éléments d¶une position, on

peut prendre un élément après l¶autre dans l¶ordre initial,
et le placer correctement dans les éléments précédents
déjà triés, comme on le fait lorsque l¶on classe ses carte à
jouer après la donne.
Le tri par insertion peut être intéressant pour des tableaux

ayant déjà été triés, mais où l¶on doit rajouter quelques
nouveaux éléments.
1
Le tri par sélection
Le but est désormais de déplacer chaque élément à sa

position définitive.
On recherche l¶élément le plus petit. Il faut donc le placer
en premier, or cette position est déjà occupée, on échange
donc les deux éléments.
Il ne reste plus qu¶à répéter l¶opération N fois.
Chaque échange met un élément en position définitive,

l¶autre par contre est mal placé. Cependant, aucun
échange n¶est inutile, car un élément qui a été bien placé,
ne sera plus testé par la suite. ß
Le tri shell
C¶est une amélioration du tri par insertion, au lieu
d¶effectuer une rotation de tous les éléments entre la
position initiale et finale d¶un élément, on peut faire des
rotation par pas de P, ce qui rendra le fichier presque trié.
Chaque élément sera à moins de P positions de sa

position exacte.
On répète ce tri pour P diminuant jusqu¶à 1.
Une suite possible pour P est de finir par 1, les pas

précédents étant de m, 13, m0, 1ß1, 3m, 10]3.
3
D¶autres suites sont possibles, à condition de prendre des
valeurs qui ne soient pas multiples entre elles, pour ne pas
toujours traiter les mêmes éléments et laisser de côté les
autres.
Les puissances successives de ß ne traiteraient que les

positions paires, sauf au dernier passage.
L¶intérêt de ce tri, est qu¶il créé rapidement un fichier

presque trié, en appliquant un dernier par insertion, celui-
ci sera beaucoup plus rapide.
m
Le tri rapide (Quick Sort)
Ce tri est récursif. On cherche à trier une partie du
tableau, délimitée par les indices gauche et droite.
On choisit une valeur de ce sous tableau que l¶on appelle

pivot (une valeur médiane serait idéale, mais sa recherche
ralentit plus le tri que de prendre une valeur aléatoire).
Puis on cherche la position définitive de ce pivot, c¶est-à-

dire que l¶on effectue des déplacements de valeurs de telle
sorte que tous les éléments avant le pivot soient plus petit
que lui et que tous ceux placés après lui soient supérieurs,
mais sans chercher à les classer, pour accélérer le ý
processus.
Puis on rappelle récursivement le tri de la partie avant le
pivot et celle de la partie après le pivot.
On arrête la récursivité sur les parties à un seul élément,

dans ce cas, le tri à obligatoirement été effectué.
Le tri par création
Lorsqu¶il est nécessaire de disposer simultanément du

tableau initial et du tableau trié, on peut recopier le
tableau initial puis effectuer un tri sur la copie ou adapter
un des algorithmes précédents.

Les autres tris
Suivant les données à trier, il peut être plus efficace de

construire un algorithme de tri spécifique.
Par exemple si un tableau contient un grand nombre de
valeurs similaires, on peut utiliser un algorithme simple,
consistant à rechercher l¶élément le plus petit, compter le
nombre de ces éléments, les mettre dans un tableau
destination, et répéter l¶opération jusqu¶à la fin du fichier.
C¶est le tri par comptage.
Le tri par fusion utilise un algorithme de fusion de deux

tableaux triés en un seul plus grand, appelé récursivement
sur les deux moitiés du tableau, jusqu¶à une taille de
tableau de 1.
â
Les algorithmes de recherche
La recherche séquentielle
A partir d¶un tableau trié, on parcours ce tableau élément
par élément jusqu¶à trouver le bon élément.
La recherche dichotomique
La recherche dichotomique recherche un élément dans un
tableau trié et retourne l¶indice d¶une occurrence de cet
élément.
On compare l¶élément cherché à celui qui se trouve au
milieu du tableau. Si l¶élément cherché est plus petit, on
continu la recherche dans la première moitié du tableau,
sinon dans la seconde moitié.
On recommence ce processus sur la moitié. On s¶arrête
lorsque l¶on a trouvé l¶élément, ou lorsque l¶intervalle de
recherche est nul.
ù
(

%
!V

0

&
* *

+

*
F

0

* ù

*

ù
ù
( )
- )

- )

-
)

= %@

-
)

G
- )
G
-
*)

*
- )
G

- )

%

*
ù
â

Dans de nombreux applications, on a besoin de regrouper plusieurs
données qui ne sont pas du même type dans une seule variable .
Mais le type différent .
Considéreront l¶exemple suivant :
Dans une banque . Chaque client est caractérisé par un ensemble de
renseignement : (nom.prénom.adresse.téléphone.n° de la carte
identité nationale.numéro de compte et solde)
Chacun de ces renseignements peut constituer une variable séparée.
Mais vu qu¶ils désignent tous un même client
Et que tous les clients possèdent les mêmes caractéristiques on peut
les regrouper dans un seul type qu'on appellera client et qui sera
constitué des composantes suivantes :
nom .Prénom.adresse.telephone.n° de carte identité nationale.n°
de compte et solde.
Chacune de ces informations s¶appelle un champ . Elle va porter un

nom et avoir un type.
Vn champ fait partie d¶un enregistrement, et l¶enregistrement client
peut se présenter de la manière suivante :
NOM Prénom Adresse Tel CIN N_cpt Solde

Les différents types de champs:
objet Type
*Client *Enregistrement
_ Nom _ chaine de caractères
_ Prénom _ chaine de caractères
_ Adresse _ chaine de caractères
_ Tel _ entiers
_ CIN _ chaines de caractères
_ N_cpt _ chaine de caractères
_ solde _ réels
Exemple:
Contenu de l¶enregistrement client
(« abidar », « rachida », « 25 sidi maarouf casa ». 064746912« jb306835 ».
« 000423580 ». 10000)
Rq:
Vn camp fait partie d¶un enregistrement, peut aussi être a son tour un
enregistrement .
L¶adresse du client peut aussi être un enregistrement qui regroupe un
numéro.rue.ville. dans ce cas on aura le schéma suivant
Objet Type
* Client * Enregistrement
_ Nom _chaine de caractère
_ Prénom _« »
_ adresse _enregistrement
*N° * entier
*Rue * chaine de caractères
*ville * chaine de caractères
_tel _ entier
_CIN _chaine de caractères
1_déclaration
1.1_syntaxe:
Type
identificateur_de_type = Enregistrement
champ1 = type 1;
champ n = type n;
fin enregistrement
Dans l¶exemple ci-dessous la déclaration sera faite de la manière
Suivante.
type
client = Enregistrement
nom : chaine de caractères ;
prénom : chaine de caractères ;
Adresse : enregistrement
n° : entier;
rue :chaine de caractères;
ville : chaine de caractères ;
fin enregistrement
tel : entier;
cin : chaine de caractères ;
n_cpt : chaine de caractères ;
solde : réel ;
fin enregistrement
Rq:
_ si plusieurs champs sont de même type,ils sont alors regroupés en les séparent par des virgules.
_lorsque il s¶agit d¶un enregistrement a l¶intérieur d¶un autre . La déclaration pourra se faire d¶une autre manière :
On définit d¶abord le type d¶enregistrement intérieur puis en l¶utilise après dans le type enregistrement général:
type
domicile = enregistrement
n° : entier ;
rue : chaine de caractères;
ville : chaines de caractères;
fin enregistrement
client = enregistrement
nom : chaine de caractères ;
prénom : chaine de caractères;
adresse : domicile;
tel : entier;
cin : chaine de caractères;
N_cpt : chaine de caractères ;
solde : réel ;
fin enregistrement
Vne fois le type client est déclaré, on peut l¶utiliser pour déclarer des variables
d¶enregistrement .
Exemple :
var
e : client ;
banque : tableau (1 1000) de client ;
1_2 : accès a un enregistrement :

on peut accéder a une variable enregistrement globalement ou par l¶ intérmédaire
de l¶une de ses composants .
1_2_1: aces global :
L¶accès a la totalité de l¶enregistrement se fait en utilisant le nom de la variable
exemple :
E E1
E1 doit être de même type que E .
Cette affectation entraîne l¶affectation des contenus respectifs de tous les champs
de la variables E1 a ceux de la variable E
1_2_2 : accès a un champs :

Le champ d¶une variable enregistrement est référencé par le nom de celle-ci
d¶un point,dit point de sélection,suivi du nom du champ.
exemple:
e.Nom moufid »;
e.Prénom soumia »;
e.adresse.n° 25;
e.adresse.rue zerktouni »;
On peut aussi utiliser l¶instruction avec » qui a la syntaxe suivante.
avec nom_de_variable faire
____
____
_ _ _ _
finavec
Exemple:
avec E FAIRE
nom « moufid »
prénom « samia »
avec adresse FAIRE
n° 25;
rue « zouktani »;
ville « casa »
finavec
tel 022349576;
cin « jb306585 »;
finavec
1_3:exercice d¶application :
dans la recherche d¶employés, un organisme a exigé d¶identifier les candidats par les caractéristiques
suivantes:
_ nom;
_ prénom;
_ date de naissance: jour,mois,année.
_ lieu de naissance : ville,province,pays.
_ état civil;
_ nationalité;
_ adresse : avenue,ville,pays,numéro code postale.
_ TÉLÉPHONE :
_ diplôme:
_stage;
Écrire un enregistrement « candidat »
solution:
type
candidat = enregistrement
nom,prénom : chaine de caractères ;

date de naissance = enregistrement
j.m.a : entiers ;
finenregistrement
lieu_naissance = enregistrement
ville,province,pays : chaine de caractères;
finenregistrement
état civil : chaine de caractères;
nationalité : chaine de caractères;
adresse : chaine de caractères ;
téléphone : entiers ;
Diplôme : chaine de caractères ;
Stage : chaine de caractères;
Finenregistrement
Exercice1: gestion des élèves
dans une classe un élève est connu par son:
_son nom;
_son prénom;
_son numéro d¶inscription;
_sa date de naissance;
_sa note a l¶examen.
O n désire écrire un algorithme permettant de faire les
opérations suivantes :
_saisie au clavier des informations de nb élèves
_calcul de
* la somme totale des notes de toute la classe stn
* la moyenne de la classe moy,
_tri du tableau des élèves par ordre décroissant des notes
_ affichage a l¶écran
* des données de chaque élèves
* de tous les résultats calculés par l¶algorithme
a/ écrire l¶enregistrement élève
b/ écrire l¶algorithme correspondant.
Exercice 2 : Calcule des salaires par tranches
Dans une Entreprise les salaires nets des employés sont calculés de la manière suivante :
SN = SB ± T + P
Avec
T = SB * TT
P = SB * TP
TT et TP sont calculés en fact. de SB selon le tableau suivant :
Tranches de SB 0 ... 500 500 3000 3001 et plus
Taux de Taxât TT 0 0.17 0.35

Taux de prime TP 0.20 0.30 0.40
On note
SN : Salaire net
SB : Salaire Brut
T : Taxe
P : Primes
On désire établir un algorithme permettant :
La saisie de données de tous les employés
Le Calcul des salaires nets
a/ Écrire un enregistrements employés
b/ Écrire un algorithme correspondant
La sortie des résultas de chaque client à l¶écran sous ka forme suivante :
Matricule : ...
Nom : ...
Prénom : ...
Salaire brut : .... Dhs
Salaire Net m : ..... Dhs
On Note
Matricule : M
Nom : N
Prénom : P
Exercice 1 :
Solution : Gestion des élèves d µune classe.
Type
Élève = enregistrement
Nom = chaîne de caractère ;
Prénom : chaîne de caractères ;
N_inscription : entier ;
Date_naissance : entier ;
Jour : entier ;
Mois :entier ;
Année : entier ;
Fin enregistrement
Const.
NE = 300 ;
Var
T : Tableau [1...30]élèves
I = entier ;
E : élèves ;
min,max,aux,M,S : réel ;
Début
Max T[1].note_examen
S 0;
pour I = 1 à NE faire
écrire (" donnez le nom d¶élève N" ,i ) ;
lire (T[i].nom) ;
écrire (" donnez le prénom d¶élève N" ,i ) ;
lire (T[i]. prénom) ;
écrire (" donnez le N_inscription d¶élève N" ,i ) ;
lire (T[i]. N_inscription) ;
écrire (" donnez la date de naissance d¶élève N" ,i ) ;
lire (T[i].date_naissance.Jour) ;
lire (T[i].date_naissance.Mois) ;
lire (T[i].date_naissance.Année) ;
écrire (" donnez la note d¶examen d¶élève N" ,i ) ;
lire (T[i].note_examen) ;
Finpour i
Pour i = 1 à NE faire
S T[i].note_examen+S ;
FinPour
M S/NE ;
Pour j = i+1 à NE faire
Si T[i].note_examen < T[j].note_examen alors
Aux T [i].note_examen ;
T[i].note_examen < T[j].note_examen ;
T[j].note_examen aux ;
FINSI
Finpourj
Finpouri
Ecrire ( T [i].E) ;
Finpouri
Ecrire (" La note Maximal est : ",T[1].note_examen) ;
Ecrire (" La note minimal est :»,T[NE].note_examen) ;
Ecrire (" La Somme de notes est : ",S) ;
Ecrire (" La moyenne de la classe est : ",M) ;
Fin
Correction :
Algorithme : Entreprise
Type employé = enregistrement
Nom : Chaîne de caractère ;
Prénom : Chaîne de caractère ;
Mat..: Chaîne de caractère ;
Sb : réel ;
Sn : réel ;
Finenregistremment
Var
T=Tableau [1 ... 100] de employées ;
I = Entier ;
T,P : réels ;
Début
Pour i allant de 1 à 100 faire
Ecrire (" Entrez Le nom " ) ;
Lire (T[i].nom) ;
Ecrire (" Entrez Le prénom " ) ;
Lire (T[i]. prénom) ;
Ecrire (" Entrez La matricule " ) ;
Lire (T[i].mat) ;
Ecrire (" Entrez Le Salaire brute " ) ;
Lire (T[i].Sb) ;
FinPour
Si T[i].Sb <= 500 alors
P T[i].Sb *0.20 ;
T[i].Sn <= T[i].Sb+P
Finsi
Si T[i].Sb > = 500 alors et T[i].Sb <= 3000 alors
T T[i].Sb*0.17 ;
P T[i].Sb*0.30 ;
T[i].Sn <= T[i].Sn-T+P ;
Finsi
Si T[i].Sb > = 3001 alors
T T[i].Sb*0.35 ;
P T[i].Sb*0.40 ;
T[i].Sn <= T[i].Sn-T+P ;
Finsi
FinPour
Ecrire (" Le nom est : ",T[i].nom) ;
Ecrire (" Le prénom est : ",T[i].prénom) ;
Ecrire (" Le Matricule : ",T[i].mat) ;
Ecrire (" Le Salaire brute: ",T[i].Sb) ;
Ecrire (" Le Salaire net : ", T[i].Sn) ;
Finpour
Fin
Les Fichiers
V

ù
Les Fichiers
à
V
V
ù
Les Fichiers
m
V

V

ù
Les Fichiers
p!
p! "

#
p! $ !

p! ! % %
&
ù
Les Fichiers
%!
'

(
p !

ù
Les Fichiers
'

) *

+ * !
m , & -
'V
.
È

È //
+È //0
V

ù
Les Fichiers
'
) * * !
à
12
12 +12 * !

m , & -

à " (mV
3
4
.
12
4

12
4
+12
'V
.
12
5
12 ///
+12 /0
ù
V à "
V

Les Fichiers
'
, -
) * * !
à
12
12 +12 * !

m , & -
È
à " (mV
È3
4
.
12
4

12
4
+12
'V
5 & -

.
12

12
12
+ 3 6788
.
12È.
123 3
+
9
V
V
5 3 & -
+ 3 6788

5
12È
123 3
+
9
V
V
5 3 & -
ù
+12È 3
V
V à "

V

Les Fichiers
p (
) *

+ * !
m , & - /
p , $

-
' .

+
È .
3
3+
(V /
V
/
ù
Les Fichiers
+
à 5+
.

5

p
V
) 512 5
5
+
)
:
$
p , $
-
'
4
512
5
p , (

-
' 512&
p , (

-
' 512&
p , ( %

-
' 512&
V
m , & -
512&
(V 512
V
V

m , & -
'V
È
à " (mV
512&
È

512&
È
/
ù
512&È
///
È3
V à "
V

V
Les Fichiers
à
Vne ecole qui voudra gerer l¶ensemble des formateurs et modules enseigne dans celle-ci
Les modules de formation sont caracterise par nom-module(8 caracteres),masse horaire(3
caracteres).
Formateur caracterise par nom(10 caracteres) , cin(5cara) et salaire(8 cara)
1-créer les structures formateur et module
2-créer les deux fichiers textes a acces sequentiel « module.txt » et « formateur.txt »
3- dans le but de gérer les deux fichiers, on veut réaliser les traitements suivants :
Ajouter un module.
Modifier la masse horaire un module.
Supprimer un module.
trier les formateurs par salaire.
La fonction chaineToRéel(chaîne) : réel, permet de convertir une chaîne en réel.

La fonction réelToChaine(réel) : chaîne, permet de convertir un réel en chaîne.
Longueur : entier, permet de renvoyer le nombre d¶éléments d¶un tableau.
Ecrire un algorithme permettant de réaliser les traitements cités ci-dessus tout en
affichant un menu approprié. L¶utilisateur peut effectuer plusieurs traitements sans avoir
besoin à relancer le programme.
ù
Les Fichiers
:
à V
+

V
à +

;
<

V
m , ,
& -
m , , & - /
V

V
/
5 ;

)
12
'
$
4

12
p ,
-
'
12&
;

p ,
-
'
12&

' mod[1]. nom-module + réelToChaine (mod[1].massehoraire)
Ouvir Module.txt » sur canal ý, en ajout
EcrireFichier ý,ligne
ù
Fermer ý
Fin de procedure
Les Fichiers
5
;

)
12
'
$
m , , & -
'V
##$= V:>(4 p= àp9'(p=
1
Tant que(non EOF(ý))
Redim(Mod[i])
Mod[i]. nom-module mid(ligne,1,8)
Mod[i].massehoraire chaineToRéel(mid(ligne,9,11))
i i+1
Fermer ý
Pour (i=1 a mod.longueur pas de 1)
Si (mod[i]. nom-module =nom) alors
Afficher donner la nouvelle valeur de la masse horaire du module»
Lire mod[i].masse horaire
Fin de pour
ÔÔ DV TA§LEAV AV FICHIER
Ouvrir module.txt » sur canal â en ecriture
Ligne mod[i].nom+ réelToChaine(mod[i].masse horaire)
EcrireFichier â,ligne
Fin de pour
Fin deprocedure
ù
Les Fichiers
5 +
;

)
12
'
$
m , , & -
'V
##$= V:>(4 p= àp9'(p=
1
Tant que(non EOF(ý))
Redim(Mod[i])
Mod[i]. nom-module mid(ligne,1,8)
Mod[i].masse horaire chaineToRéel(mid(ligne,9,11))
i i+1
Fermer ý
Si (mod[i]. nom-module =nom) alors
Pour(j= i a mod.longueur pas de 1)
mod[j] mod[j+1]
Fin de pourj
Fin de pouri
Redim (mod[mod.longueur-1])
Ouvrir module.txt » sur canal â en ecriture
Ligne mod[i].nom+ réelToChaine(mod[i].masse horaire)
EcrireFichier â,ligne
ù
Fin de pour
Fin de procedure
Les Fichiers
5

) 12 V

p V

)
$
m , ,
& - ?
'V ?
##$= V:>(4 p=@ àp9'(p=@
1
Tant que(non EOF(]))
Redim(for[i])
for[i]. nom mid(ligne,1,10)
for[i]. cin mid(ligne,11,15)
for[i].salaire chaineToRéel(mid(ligne,16,23))
i i+1
Fermer ]
V for.longueur
Tanque V>1
Pour (i=1 a V-1 pas de 1)
Si (for[i]. salaire > for[i+1]. salaire ) alors
Aux for[i]
for[i] for[i+1]
for[i+1] Aux
FinSi
FinPouri
V V-1
FinTantque
Fin
Ouvrir formateur.txt » sur canal ù en ecriture
Pour (i=1 a for.longueur pas de 1)
ù
Ligne for[i].nom+ for[i].cin+ réelToChaine(for[i].salaire)
EcrireFichier ù,ligne
Fin de pouri
Fin de procedure
5

$
nomod : chaine de caractere
Rpter
Ecrire ("----------------------- Menu ---------------------------")
Ecrire ("1- Ajouter module ")
Ecrire ("2- Modifier module ")
Ecrire ("3- Supprimer module ")
Ecrire ("4- trier formateur ")
Ecrire ("5- Quitter")
Ecrire ("-----------------------------------------------------------")
Ecrire ("Veuillez entrer votre choix :")
Lire (choix)
Cas choix
1 : ajout-module();Sortir cas
2 : crire ("Entrer le nom du module a modifier")
Lire(nomod)
modifier-module(nomod);Sortir cas
3 : crire ("Entrer le nom du module a modifier")
Lire(nomod);supprimer-module(nomod);Sortir cas
4 : trierformateur();Sortir cas
5 : crire ("Vous avez choisi de quitter le programme");Sortir cas
Sinon : crire ("Votre choix est incorrect. Veuillez choisir entre 1 et 5")
Sortir cas
Fin cas
Jusqu%A choix=5
Fin

Cours Algorithmique 3

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cours Algorithmique 3

Uploaded by

Copyright:

Available Formats

ALGORITHME

 Nous présentons les algorithmes comme une suite

Nous manipulerons les types couramment rencontrés

- Nom : le nom de l'algorithme

- il est délimité par les mots clés début et fin.

 Il en va de même pour les fonctions, dont l'identifiant

 un type qui caractérise l¶ensemble des valeurs que peut

 L¶ensemble des variables est stocké dans la mémoire de

 réel pour manipuler des nombres réels

 booléen pour manipuler des valeurs booléennes

 caractère pour manipuler des caractères alphabétiques

 Une variable est l'association d'un nom avec un type,

 Une R érande est une entité (variable, constante ou

 Une ex ressiRn est une combinaison d¶opérateur(s) et

Si par exemple a vaut ß et b 3, l¶expression a + b vaut ý

Si par exemple a et b sont des entiers, l¶expression a + b est un

 Un opérateur est associé à j type de donnée et ne peut être

 Par exemple l¶opérateur + ne peut être utilisé qu¶avec les

 La signification d¶un opérateur peut changer en fonction

 Rappels sur la logique booléenne...

 Associativité des opérateurs et et ou

 Commutativité des opérateurs et et ou

 Involution (homographie réciproque)

 On retrouve tout naturellemment +, -, *, /

 On a aussi l¶opérateur d¶inégalité : 

 Et pour les types possédant un ordre les opérateurs de

 Pour clarifier les choses (ou pour dans certains cas

ß. Affecter un (nouveau) contenu

La syntaxe de cet opérateur est : ß0

 Si c avait auparavant une valeur, cette dernière est perdue !

 Il peut afficher un résultat (du texte ou le contenu d¶une

 demander à l¶utilisateur de saisir une information afin

 En tant qu¶informaticien on raisonne en se mettant  la ßß

Cette instruction réalise simplement l'affichage des valeurs

 Exemple d'utilisation : écrire(x, y+ß, "bonjour") ß3

variable <- lire()

L'exécution de cette instruction consiste à affecter une valeur

Avant l'exécution de cette instruction, la variable avait ou ßm

v1,. . . ,vn sont des cRnstantes de type scalaire (entier, naturel,

 Forme de la boucle Pour :

Pour variable de valeur initiale à valeur finale faire

 La valeur utilisée pour énumérer les itérations est appelée

Pour variable décroissante de valeur initiale à valeur finale

La variable d'itération est décrémentée de 1 après chaque

 Syntaxe de la boucle Tant que :

 Il faut que la liste des instructions ait une incidence sur la

 Il faut toujours s'assurer que la condition devient fausse au

Un utilisateur peut construire des rectangles de taille

La séquence d'instructions est exécutée au moins une fois et

 Différences entre les boucles Tant que et Répéter jusqu'à :

- la séquence d'instructions est exécuter si la condition est vrai

- Dans les deux cas, la séquence d'instructions doit

retourne une chaîne formée par la concaténation de O et de O . La chaîne

retourne la longueur de la chaîne O c'est-à-dire le nombre de caractères dont elle

retourne une sous-chaîne de longueur  extraite de la chaîne O , à la position .

exemple : sousChaîne("informatique"", 6, 2) retourne la chaîne "ma".

retourne le ième caractère de la chaîne O .

 a   

remplace le ième caractère de la chaîne O par la

 Le type d'un tableau précise le type (commun) de tous les

 En général, nous choisirons toujours la valeur 0 pour la

 Ce tableau est de longueur 10, car il contient 10

 Pour accéder à un élément du tableau, il suffit de préciser

Nous présentons les algorithmes comme une suite

Nous manipulerons les types couramment rencontrés

Il en va de même pour les fonctions, dont l'identifiant

un type qui caractérise l¶ensemble des valeurs que peut

L¶ensemble des variables est stocké dans la mémoire de

réel pour manipuler des nombres réels

booléen pour manipuler des valeurs booléennes

caractère pour manipuler des caractères alphabétiques

Une variable est l'association d'un nom avec un type,

Une R érande est une entité (variable, constante ou

Une ex ressiRn est une combinaison d¶opérateur(s) et

Un opérateur est associé à j type de donnée et ne peut être

Par exemple l¶opérateur + ne peut être utilisé qu¶avec les

La signification d¶un opérateur peut changer en fonction

Rappels sur la logique booléenne...

Associativité des opérateurs et et ou

Commutativité des opérateurs et et ou

Involution (homographie réciproque)

On retrouve tout naturellemment +, -, *, /

On a aussi l¶opérateur d¶inégalité :

Et pour les types possédant un ordre les opérateurs de

Pour clarifier les choses (ou pour dans certains cas

Si c avait auparavant une valeur, cette dernière est perdue !

Il peut afficher un résultat (du texte ou le contenu d¶une

demander à l¶utilisateur de saisir une information afin

En tant qu¶informaticien on raisonne en se mettant la ßß

Exemple d'utilisation : écrire(x, y+ß, "bonjour") ß3

Forme de la boucle Pour :

La valeur utilisée pour énumérer les itérations est appelée

Syntaxe de la boucle Tant que :

Il faut que la liste des instructions ait une incidence sur la

Il faut toujours s'assurer que la condition devient fausse au

Différences entre les boucles Tant que et Répéter jusqu'à :

retourne une sous-chaîne de longueur extraite de la chaîne O , à la position .

a

Le type d'un tableau précise le type (commun) de tous les

En général, nous choisirons toujours la valeur 0 pour la

Ce tableau est de longueur 10, car il contient 10

Pour accéder à un élément du tableau, il suffit de préciser

Les tableaux peuvent avoir n dimensions.

(*

89:!;

Les mêmes remarques que pour la procédure s'appliquent.

L'appel d'une fonction s'écrit :

Elle est utilisée ainsi :

Exemple : la formule de calcul de la factorielle d¶un nombre n

Pour programmer cela, il faut une fonction Facto, chargée de

Il est à noter que l'on traite le problème à l¶envers : on part

Cet effet de rebours est caractéristique de la

Le tri par création

Chacune de ces informations s¶appelle un champ . Elle va porter un

1_2 : accès a un enregistrement :

1_2_2 : accès a un champs :

p! "

'

5 & -

+ 3 6788

V à "

p , (

p , ( %

Modifier la masse horaire un module.

trier les formateurs par salaire.

La fonction chaineToRéel(chaîne) : réel, permet de convertir une chaîne en réel.