PARTIE I: L'ALGORITHMIQUE

I) GENERALITES
1) Définitions.
Ordinateur:
Un ordinateur est une machine capable d'effectuer toute sorte d'opérations et de traitements (tel
que des calculs, traitement de textes et d'images) sur des données stockées dans la mémoire vive à
l’aide de programmes informatiques et renvoyer des résultats soit dans une autre partie de la
mémoire où elles sont stockées en vue d'opérations ultérieures, soit à la sortie où elles seront
présentées sous une forme utilisable dans le monde extérieur.
Les programmes, données et résultats sont enregistrés dans la mémoire vive de l’ordinateur.

Programme :
Pour donner des ordres à l'ordinateur, il est nécessaire de pouvoir communiquer avec lui. Cette
communication passe par un langage de programmation, dans lequel est écrit le programme.

Un programme est un ensemble d’ordres élémentaires, appelées instructions, écrites dans un

langage de programmation, et exécutées par un ordinateur afin de traiter les données d’un
problème (entrées) et renvoyer un ou plusieurs résultats (sorties).

Par exemple, Un programme de paye nécessite des données d'employés : noms, situations de
famille, nombres d’heures supplémentaires, etc… Les résultats seront imprimés sur les différents
bulletins de paye.

2) Le processus de la programmation
La programmation consiste à déterminer la démarche permettant d’obtenir, à l’aide d’un ordinateur,
la solution d’un problème donné.
Le processus de la programmation se déroule en deux phases :
 L’analyse du problème posé et la recherche d’un algorithme qui consiste à définir les
différentes étapes de la résolution du problème.
 Exprimer dans un langage de programmation donné, l’algorithme élaboré dans l’étape
précédente.

II) Notion d’algorithme.

1) Définition
Un algorithme est une suite finie d’opérations élémentaires, appelées instructions, exécutées dans
un ordre bien déterminé décrivant les étapes de résolution d’un problème.
Un algorithme est une suite d’actions ou d’instructions élémentaires exécutées dans un ordre
bien déterminés pour résoudre un problème.(ou réaliser un travail)

Un algorithme est une succession d'instructions à enchaîner dans un ordre bien précis,
permettant de résoudre un problème de façon systématique. Il est écrit dans un langage
compréhensible par tous.
 2) Représentation d’un algorithme
On peut représenter un algorithme à l’aide d’un pseudo-code ou d’un algorigramme
(organigramme).
a) L’algorigramme
(i) Définition
C’est une représentation graphique de l’algorithme. Pour le construire, on utilise des symboles
normalisés.
(ii) Quelques symboles utilisés dans Un algorigramme :

SYMBOLE DESIGNATION
Symbole général Opération ou groupe
d’opérations sur des données, instructions,
pour laquelle il n’existe aucun symbole
normalisé.

Sous‐programme Portion de programme

considérée comme une simple opération.

Entrée‐Sortie Mise à disposition d’une

information à traiter ou enregistrement
d’une information traitée.

Branchement Exploitation de conditions

variables impliquant un choix parmi
plusieurs.
 Renvoi Symbole utilisé deux fois pour
assurer la continuité lorsqu’une partie de
ligne de liaison n’est pas représentée.

Début, fin, interruption Début, fin ou

interruption d’un algorigramme.

Commentaire Symbole utilisé pour donner

des indications sur les opérations effectuées.

Les différents symboles sont reliés entre eux par des lignes de liaisons.
Cette représentation n'est plus utilisée actuellement à cause de son encombrement.

b) Le pseudo-code

Le pseudo-code est un langage de description d’algorithme (LDA).

Ce langage utilise un ensemble de mots clés et de structures permettant de décrire de manière
complète, claire, l’ensemble des opérations à exécuter sur des données pour obtenir des résultats.
L’avantage d’un tel langage est de pouvoir être facilement transcrit dans un langage de
programmation structuré (Pascal, C…) Ou programmation orienté objet (java,python)

3) Les données d’un algorithme

Les données sont des informations nécessaires au déroulement d’un algorithme. On distingue deux
catégories de données: les constantes et les variables.
a) Les constantes
Une constante, est un objet dont le contenu ne varie pas durant l’exécution d’un algorithme.
Une constante est caractérisée par son nom et sa valeur (fixe)
b) Les variables
Une variable est un objet dont le contenu peut être modifié par une action durant l’exécution d’un
algorithme.
Une variable est caractérisée par son nom, sa valeur et son type.
4) Différences entre algorithmes et programmes
Un programme est la réalisation (l’implémentation) d’un algorithme au moyen d’un langage donné
(sur une architecture donnée).

III) Structure d’un algorithme

1) Représentation :
 L’en-tête Algorithme nom_de_l’algorithme
const
Les déclarations de: liste des constantes ;
 Constantes, var
 Variables, liste des variables ;
 Structures struct
 Les fonctions et liste des structures ;
procédures
fonc
Les déclarations de: liste des fonctions ;
fonctions et procédures proc
liste des procédures ;

début
action 1 ;
action2 ;
.
Le corps de l’algorithme .
.
action n ;
fin algorithme

 L’en-tête: permet d’identifier l'algorithme.

 Les déclarations: C’est une liste des objets utilisés et manipulés dans le corps de
l’algorithme ; cette liste est placée en début d’algorithme.
 Le corps: Dans cette partie de l’algorithme, sont placées les actions (instructions,
opérations…) à exécuter.
 a) Les commentaires :
Pour permettre une interprétation aisée de l’algorithme, l’utilisation de commentaires est vivement
conseillée.

2) Composition d’un algorithme

En algorithmique, il existe quatre catégories d'ordres (d'instructions):
 L’affectation de variables
 La lecture / écritnure
 Les tests
 Les boucles
3) Importance de l'algorithmique
Parce que l’algorithmique exprime les instructions résolvant un problème donné indépendamment
des particularités de tel ou tel langage.
Apprendre l’algorithmique, c’est apprendre à utiliser la structure logique d’un programme
informatique. Cette structure est présente quelle que soit le langage de programmation ; mais
lorsqu’on programme dans un langage (en C, en Visual Basic, etc.) on doit en plus respecter la
syntaxe, ou types d’instructions, propres à ce langage.

IV)Les variables et les constantes

Présentation
Les programmes ont pour but de traiter différentes données afin de produire des résultats. Les
résultats peuvent eux-mêmes être des données pour d'autres programmes.
Les données d'un programme doivent être récupérées en mémoire centrale, à partir du clavier ou
d'un fichier par exemple, pour pouvoir être traitées par le processeur qui exécute le programme.
Ainsi, toutes les données d'un programme sont mémorisées en mémoire centrale, dans des cases
mémoires que l'on appelle variables.
1) Les variables
Une variable est un espace mémoire repéré par nom (une adresse binaire) et contenant la valeur
d'une donnée. La valeur d'une variable peut varier au cours du programme.
.
Une variable est caractérisée par :
 Un nom unique appelé identificateur par lequel on peut accéder à son contenu.
 Un type: représentant la nature de la donnée qu'elle stocke (nombre, lettre, chaine…).
 Une valeur.

2) Les constantes
Une constante, est un espace mémoire repéré par nom et dont la valeur ne change pas durant
l’exécution d’un programme.
Une constante est caractérisée par son nom et sa valeur (fixe) attribuée lors de la déclaration.

3) Déclaration des variables et constantes

Avant de pouvoir utiliser une variable ou une constante, il faut la déclarer c.à.d. lui réserver un
espace mémoire.
La déclaration des variables se fait par un le mot clé Variable suivit d’un nom puis du type de la
variable.
La déclaration des constantes se fait par un le mot clé constante suivit d’un nom puis de la
valeur.
Syntaxe :
Constantes
nomConstante  valeur
Variables
NomVariable : Type
Exemple :
Constantes
Pi 3.14
Variables
age : entier

Le nom d’une variable doit respecter certaines règles:

  Doit commencer par une lettre ou le caractère souligné (_).
 Ne doit pas comporter des signes de ponctuation ni d’espaces.
 Peut comporter des chiffres et des lettres.
4) Les types de données
En algorithmique, on distingue 5 types principaux :
 Les entiers (les nombres sans virgule) ;
 Les réels (les nombres à virgule et sans virgule) ;
 Les booléens (qui n'ont que deux valeurs possibles: soit VRAI, soit FAUX).
 Les caractères (lettres, chiffres, ponctuation, code des opérations, espace, retour chariot, et
plus généralement toutes les touches que l'on peut trouver sur une machine à écrire) ;
 Les chaînes de caractère (suites de caractères) ;

Remarque :
 Le type de variable choisi pour un nombre va déterminer les valeurs maximales et minimales
des nombres pouvant être stockés dans la variable. Elle détermine aussi la précision de ces
nombres (dans le cas de nombres décimaux).
 Une chaîne de caractères est notée entre guillemets " ".
 Une valeur de type caractère est notée entre des apostrophes ' '.
Cette notation permet d’éviter:
 De Confondre un chiffre et une suite de chiffres. Par exemple, 423 peut représenter le
nombre 423 (quatre cent vingt-trois), ou la suite de caractères 4, 2, et 3 notée "423".
 De confondre le nom d'une variable et son contenu.

V) Expressions et opérateurs
1) Opérateurs
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.
Les opérateurs possibles dépendent du type de valeurs qui sont mises en jeu dans l’expression.
a) Opérateurs numériques :
Quelques opérateurs arithmétiques.
+ addition
- soustraction
* multiplication
/ Division
^ « puissance ».
% ou Mod modulo : reste de la division entière d’une valeur par une autre.
Div Division entière
 e
La multiplication et la division ont « naturellement » priorité sur l’addition et la soustraction. Les
parenthèses ne sont ainsi utiles que pour modifier cette priorité naturelle.
b) L'Opérateur alphanumérique : &
Pour le type chaîne, on a un seul opérateur qui permet de concaténer (joindre) deux chaînes de
caractères. Cet opérateur de concaténation est noté & ou +.
Exemple :
Variables A, B, C : chaine
Début
A ← "Hassnaoui"
B ← "karim"
C←A&B
Fin
La valeur de C à la fin de l’algorithme est "hassnaouikarim"
c) Opérateurs logiques (ou booléens) :
Il s’agit du ET, du OU, du NON et du XOR(ou exclusif).
 2) Les Expressions
Une expression est un ensemble de variables (ou valeurs) reliées par des opérateurs. Une
expression et toujours équivalente à une seule valeur.
Exemple:
7 5+4 x + 15 – y/2
nom&prenom
Où x et y sont des variables numériques (réels ou entiers) et nom et prenom sont des variables
chaîne.

Dans une expression où on trouve des variables ou valeurs numériques, l’ordre de priorité des
opérateurs est important. En effet, la multiplication et la division sont prioritaires par rapport à
l’addition et la soustraction.
Exemple:
12 * 3 + 5 donne comme résultat 41.
Si l’on veut modifier cet ordre de priorité on sera obligé d’utiliser les parenthèses.
Par exemple, 12 * (3 + 5) donne comme résultat 96.

VI)Les instructions de base

 1) La lecture (saisie)
La lecture est une instruction qui permet au programme de lire(capter) des données tapées au
clavier par l'utilisateur et de les affecter (stocker) à une variable.
Syntaxes :
Lire (NomVariable) ou Lire NomVariable;

Lire (variable1, variable2) ; ou Lire NomVariable1, NomVariable 2 ;

Exemple :
Lire (note) ;
Lire (A, B) ;
Lire v1, v2

2) L’écriture (l'affichage)

L’écriture est une instruction qui permet au programme d'afficher des valeurs sur l'écran.
Ces valeurs peuvent être :
 Le contenu d’une variable.
 Un message (chaine de caractères).
 Le résultat d’une expression.
Syntaxe :
Ecrire (variable) ;
Ecrire (" message") ;
Ecrire ("message", variable) ;
Exemple :
Soit A est une variable.
Ecrire (A) : signifie afficher sur l’écran le contenu de la variable A.
Ecrire ("donnez votre nom : ") : signifie afficher sur l’écran le message: donnez votre nom :

3) L’affectation
L’affectation est une opération qui consiste à attribuer une valeur à une variable. Elle est
représentée par une flèche ( ) orientée à gauche

Syntaxe :
Variable  Valeur ou expression
Exemple
A 2 : la variable A reçoit la valeur 2
B A+1 : la variable B reçoit le contenu de de la variable A plus 1
Nom"Mohamed" : la variable Nom reçoit la valeur "Mohamed".
Reponse  'o'

Remarque :
 L’instruction d’affectation ne modifie que ce qui est situé à gauche de la flèche.
 La valeur de la partie droite doit obligatoirement être du type de la variable affectée.

a) Initialisation des variables

Toutes les variables doivent être initialisées (recevoir une valeur initiale) avant leur utilisation.
L’initialisation s’effectue généralement au début du programme, juste après les déclarations. Elle
prend la forme d'une simple affectation ou d’une saisie au clavier.
Exemple
Algo initialisation
/*déclarations*/
Variables
x , y : entiers
a : chaîne
Début
/* initialisation */
x 0
y10
a"hello"
/* autres instructions */
Fin
VII) Conception d'un algorithme
Pour concevoir un algorithme, il faut suivre les étapes suivantes :
 Etape1: Lire et comprendre bien l’énoncé du problème à résoudre
 Etape 2:
o Définir les résultats du problème (les sorties) ;
o Définir les données du problème (les entrées) ;
o Définir le traitement (les relations permettant d’obtenir les résultats à partir des
données) ;
 Etape 3: Ecrire l’algorithme en respectant la structure pseudo-code

Exemple1
Un algorithme qui demande la valeur du rayon pour calculer la surface d’un disque
Etape1 : on veut calculer la surface d’un disque.
Etape 2:
Résultats: La surface du disque Surf
Données:
Le rayon R
3,14 Pi
Traitements
Surf = Pi * R*R
Etape 3:
Algorithme Surface_ disque
Constantes
Pi = 3,14 ;
Variables
R, Surf : Réel ;
Début
Ecrire ("Donnez la valeur de rayon: ") ;
Lire (R) ;
Surf Pi*R^2 ;
Ecrire (" La surface du disque est : ", Surf) ;
Fin.
Type dedonnées Numérique Alphanumérique Booléen
Entier
(sans la virgule)
Réel
(Avec et sans la virgule)
Caractères Chaîne decaractères
Exemples
-345
178
2012
-123,56 4,1×1038
56,12 18
3 -123
'A,' '@'
'2 ' '?'
'+' '$'
'Ibn Batouta'
'49', '3872'
'Bonjour'
Vrai
Faux
Remarque
'32' est différent de 32 parce que 32 est trente-deux par contre '32'représente la suitedes chiffres
3et2.
Une variable de type numérique ne peut pas recevoir une chaine de caractères oubooléen.

VIII) Les structures de contrôles:

Les opérations élémentaires relatives à la résolution d’un problème peuvent, en fonction de leur
enchaînement être organisées suivant quatre familles de structures algorithmiques fondamentales.
 Structures linéaires
 Structures alternatives
 Structures de choix
 Structures itératives (ou répétitives)

6.1 Caractéristique de la structure linéaire

La structure linéaire se caractérise par une suite d’actions à exécuter successivement dans l’ordre
énoncé.
6.2 Caractéristique de la structure alternative
La structure alternative n’offre que deux issues possibles à la poursuite de l’algorithme et s’excluant
mutuellement.
Action1 Action2 Action3 Action4
On peut rencontrer deux types de structures alternatives :
Notation : Action1
Action2
Action3
Action4
6.2.1 Une structure alternative complète
Dans cette structure l’exécution d’un des deux traitements distincts ne dépend que du résultat d’un
test effectué sur la condition qui peut être une variable ou un événement.
• Si la condition est vérifiée seul le premier traitement est exécuté.
• Si la condition n’est pas vérifiée seul est effectué le second traitement. Condition Action1 Action2
Notation : Si (Condition) Alors
Action1
Sinon
Action2
FinSi
6.2.2 Une structure alternative réduite
La structure alternative réduite se distingue de la précédente par le fait que seule la situation
correspondant à la validation de la condition entraîne l’exécution du traitement, l’autre situation
conduisant systématiquement à la sortie de la structure.
Condition Action
Notation : Si (Condition) Alors
Action
FinSi
6.3 Caractéristique de la structure de choix
La structure de choix permet, en fonction de plusieurs conditions de type booléen, d’effectuer des
actions différentes suivant les valeurs que peut prendre une même variable.
Notation : Suivant (Valeur) Faire Condition1Action1Condition2ConditionnAction2 Action n Action
n+1
Valeur 1 : Action1
Valeur 2 : Action2
Valeur n : Action n
Sinon : Action n+1
FinSuivant

1) Les structures conditionnelles

Une structure de test (appelée aussi structure alternative) est une structure dans laquelle le
programme exécute une Séries d’instructions ou une autre selon qu’une condition soit vraie ou
fausse.
Une condition est une expression booléenne (conditionnelle ou logique).
Il existe 2 formes principaux de structures conditionnelles

 Les structures alternatives (Si…Alors…Sinon)

 Les structures conditionnelles au sens strict (Si…Alors)

a) Forme simple (Si…Alors):

Si (condition) Alors
Instructions1
Finsi

La série d’instructions 1 sera exécutée seulement si la condition est réalisée.

b) La forme complète (Si…Alors…Sinon):
Si (condition) Alors
Bloc 1 d'Instructions
Sinon
Bloc 2 d'Instructions
Finsi
Si la condition est vrai le bloc1 d'instructions est exécuté. Le bloc2 est ignoré.
Si la condition est fausse, le bloc1 est ignoré et c'est le bloc 2 est exécuté.

c) La structure Selon…Faire (de choix)

La structure Selon permet de choisir le traitement à effectuer en fonction de la valeur ou de
l'intervalle de valeur d'une variable ou d'une expression. Cette structure permet de remplacer
avantageusement une succession de structures Si…Alors.
La syntaxe de cette structure est
Selon expression Faire
Cas valeur 1: traitement 1
Cas valeur 2 .. valeur3 : traitement 2
Cas <valeur 3 : traitement 3
Cas valeur4, valeur5,… ,valeurN: traitement4
…
Cas Sinon : traitement par défaut
Finselon
REMARQUE:
Pour certains langages de programmation (comme C), l'expression est comparée avec des valeurs
littérales uniquement.
Syntaxe:
Selon expression faire
Valeur 1 : instruction 1 ;
Valeur 2 : instruction 2 ;
Sinon : instruction 3 ;
FinSelon ;
Exemple1: Algorithme qui affiche le nom du mois correspondant à un numéro.
Le numéro du mois en mémorisé dans la variable mois.
Selon mois Faire
1 : Ecrire "Janvier"
2 : Ecrire "Février"

3 : Ecrire "Mars"
4 : Ecrire "Avril"
…
11 : Ecrire "Novembre"
12 : Ecrire "Décembre"

Sinon: Afficher "Un numéro de mois doit être compris entre 1 et 12" Finselon
Exemple 2:
Les différents cas possibles sont décrits par des intervalles de valeur (taux de remise
différent selon le montant d'achat) …
Selon montant Faire
<1000 : taux 1
≥1000 et < 3000: taux 2
≥3000 et < 10000: taux 3
≥ 10000: taux 4
FinSelon
montant montant * ( 1 – taux/100)
…

Les structures itératives (répétitives)

Une structure répétitive sert à répéter un ensemble d’instructions un certain nombre de fois.
Les structures répétitives, appelées aussi boucles, permettent de répéter un ensemble d’instructions
autant de fois qu'il est nécessaire : soit un nombre déterminé de fois, soit tant qu'une condition est
vraie.
Il existe trois formes de structures répétitives :
 La structure TantQue…Faire : permet d'effectuer une instruction tant qu'une condition est
satisfaite.
 La structure Pour : permet de répéter une instruction un certain nombre de fois.
 La structure Répéter…Jusqu'à : comme son nom l'indique, elle permet de répéter un bloc
d'instructions jusqu'à ce qu'une condition soit satisfaite.

La Structure RÉPÉTER … JUSQU’À …

Cette structure sert à répéter des instructions jusqu’à ce qu’une condition soit réalisée.
Syntaxe:
REPETER
Instructions à répéter
JUSQU'A condition
Exemple
Considérons l’algorithme suivant :
Variables a, c : Entiers
DEBUT
REPETER
Lire a
Cc*c
Ecrire c
JUSQU'A (a = 0)
Ecrire ( "Fin" )
FIN

Exécution:
Le traitement est exécuté, puis la condition est vérifiée. Si elle n'est pas vraie, on retourne au début
de la boucle et le traitement est répété. Si la condition est vraie, on sort de la boucle et le
programme continue séquentiellement. A chaque fois que le traitement est exécuté, la condition
d'arrêt est de nouveau vérifiée à la fin.
Les instructions, entre « REPETER et JUSQU'A » sont exécutée au moins une fois.
Exemple :
Algorithme Aire
Variables
rayon : réel
reponse : chaîne
Début
Afficher "Calcul de l'aire d'un cercle"
Répéter
Afficher "Entrez le rayon d'un cercle en cm"
Saisir rayon
Afficher "L'aire de ce cercle est ", rayon*rayon *3.14, "cm²"
Afficher "Voulez-vous l'aire d'un autre cercle? (oui/non)"
Saisir réponse
Jusqu'à réponse = "oui" //si la réponse est différente de "oui", la répétition du traitement s'arrête
Afficher "Au revoir!"
Fin

Exercices boucles
1. Ecrire un algorithme qui demande successivement des nombres à l’utilisateur, et qui calcule
lenombre de valeurs saisies. La saisie des nombres s’arrête lorsque l’utilisateur entre le caractère «
n » ou « N ».
2. Ecrire un algorithme qui demande successivement des nombres à l’utilisateur, et qui calcule leur
moyenne. La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro.
3. Modifiez l’algorithme de l’exercice 1, de façon qu’il nous renseigne sur le nombre des valeurs
positives et sur le nombre des valeurs négatives. Ne comptez pas les valeurs nulles.
4. Ecrire un algorithme qui lit les caractères saisis par l’utilisateur. A la fin ce programme nous
affichera la phrase saisie. La saisie des caractères s’arrête lorsqu’on tape point « . ». Pour
l’utilisateur veut insérer un espace il lui suffit de tapez sur 0. Par exemple si l’utilisateur tape
successivement les caractères « b » , « o », « n », « j », « o », « u », « r » , « t », « o », « u », « s
», « . » , il nous affichera la chaîne « bonjour tous ».
Mais si il tape « b », « o », « n », « j », « o », « u », « r », « 0 », « t », « o », « u », « s », « . » ,
le programme affichera « bonjour tous ».
Solutions
1. le programme est :
Variables a, compteur : Entiers
Variable reponse : Chaîne
DEBUT
compteur 0
REPETER
Ecrire « Entrez un nombre : »
Lire a
compteurcompteur + 1
Ecrire « Voulez-vous continuez Oui/Non ? »
Lire reponse
JUSQU'A reponse = « N » ou reponse = « n »
Ecrire « Le nombre de valeurs saisies est : » , compteur
FIN

2. Le programme est :
Variables a, somme, moyenne, compteur : Entiers
DEBUT
compteur 0
somme 0
REPETER
Ecrire « Entrez un nombre : »
Lire a
compteurcompteur + 1
sommesomme + a
JUSQU'A a = 0
Moyenne  somme / compteur
Ecrire « La moyenne de valeurs saisies est : » , moyenne
FIN

3. le programme est :
Variables a ,npos , nneg : Entiers
Variable reponse : Chaîne
DEBUT
npos 0
nneg 0
REPETER
Ecrire « Entrez un nombre : »
Lire a
SI a > 0 ALORS
Nposnpos + 1
SINON
SI a < 0 ALORS
nnegnneg + 1
FIN SI
2. Le programme est :
Variables a , somme , moyenne , compteur : Entiers
DEBUT
compteur 0
somme 0
REPETER
Ecrire « Entrez un nombre : »
Lire a
compteur compteur + 1
somme somme + a
JUSQU'A a = 0
Moyenne  somme / compteur
Ecrire « La moyenne de valeurs saisies est : » , moyenne
FIN

3. le programme est :
Variables a ,npos , nneg : Entiers
Variable reponse : Chaîne
DEBUT
npos 0
nneg 0
REPETER
Ecrire « Entrez un nombre : »
Lire a
SI a > 0 ALORS
nposnpos + 1
SINON SI a < 0 ALORS
nnegnneg + 1
FIN SI

FIN SI
Ecrire « Voulez-vous continuez Oui/Non ? »
Lire reponse
JUSQU'A reponse = « O » ou reponse = « o »
Ecrire « Le nombre de valeurs positives saisies est : » ,npos
Ecrire « Le nombre de valeurs négatives saisies est : » ,nneg
4. Le programme est :
Variables caractere , phrase : Chaîne de caractère
DEBUT
phrase ""
REPETER
Ecrire « Entrez un caractère : »
Lire caractère
SI caractere = "0" ALORS
caractere " "
FIN
FIN SI
phrasephrase + caractere
JUSQU'A caractere = " ."
Ecrire " La phrase résultante est : " , phrase

La structure TANT QUE

Cette structure permet de répéter les instructions tant qu’une condition est satisfaite (vraie).
Syntaxe :
TANTQUE (condition)
Instructions à répéter
FIN TANTQUE

 Condition : c’est un test (comparaison) qu’on appelle parfois condition d’arrêt. Cette
condition est testée avant la première exécution.
Dans cette structure, on commence par tester la condition ; si elle est vérifiée, le traitement est
exécuté.

Exercices
EX1. Ecrire un algorithme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce
que la réponse convienne.
EX2. Ecrire un algorithme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la
réponse convienne. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus petit
! », et inversement, « Plus grand ! » si le nombre est inférieur à 10.
EX 3. Ecrire un algorithme qui demande un nombre de départ, et qui ensuite affiche les dix
nombres suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les
nombres de 18 à27.
EX 4. Ecrire un algorithme qui demande successivement des nombres à l’utilisateur, et qui lui dise
ensuite quel était le plus grand parmi ces nombres et quel était sa position. La saisie des nombres
s’arrête lorsque l’utilisateur entre un zéro.
EX 5. Lire la suite des prix (en dhs entiers et terminée par zéro) des achats d’un client. Calculer la
somme qu’il doit, lire la somme qu’il paye, et déterminer le reste à rendre.

Solutions
EX 1. Le programme est :
Variable a : Réel
Début
Tant Que a < 1 OU a > 3
Ecrire « Veuillez Saisir une valeur comprise entre 1 et 3 »
Lire a
Fin Tant Que
Fin
EX 2. Le programme est :
Variable a : Réel
Début
Lire a
TantQue (a < 10 OU a > 20)
 Si a < 10 Alors
Ecrire « Plus grand ! »
Fin
Sinon
Fin Si
Lire a
Fin Tant Que
Ecrire « Plus petit ! »

EX 3. Le programme est :
Variable a , i : Réel
Début
Ecrire « Entrez un nombre »
Lire a
ia+1
TantQue i < a + 10
Ecrire i
ii+1
FinTant Que
Fin
EX 4. Le programme est :
Variables i, a, max, pmax : Entiers
DEBUT
Ecrire « Entrez le nombre numéro 1 »
Lire a
max a
pmax 1
i1
TANTQUE a <> 0
i i + 1
Ecrire « Entrez le nombre numéro », i
Lire a
SI a > max ALORS
max a
pmax i
FIN SI
FIN TANT QUE
Ecrire « Le plus grand nombre est : », max
Ecrire « Sa position est : », pmax
EX 5. Le programme est :
Variables prixlu ,mdu , mpaye , reste : Entiers
DEBUT
Ecrire « Entrez le prix »
Lire prixlu
 mdu 0
mdumdu + prixlu
TANT QUE prixlu<> 0
Ecrire « Entrez le prix »
Lire prixlu
mdumdu + prixlu
FIN TANT QUE
Ecrire « Entrez le prix payé»
Lire mpaye
restempaye - mdu
Ecrire « Le reste est : » , reste
FIN

La structure POUR
Cette structure permet de répéter des instructions un nombre connu de fois.

Syntaxe :
POUR compteur allant de val_initial A val_Final PAS DE incrément
Instructions à répéter
FinPOUR

Compteur: C’est une variable entière de contrôle d’itération.

val_initial et val_final: sont respectivement les valeurs initiale et finale prise par le compteur. Ce
sont des valeurs entières.
Incrément: est la valeur d'incrémentation du compteur. La valeur par défaut du pas est de 1.
Dans de telle on peut ne pas le préciser.
Remarques:
 Si la valeur initiale est supérieure à la valeur finale, le pas d'incrément doit être négatif.
 Si la valeur initiale est égale à la valeur finale, la boucle sera exécutée une seule fois.
Exercices:
EX1: Ecrire un algorithme qui demande un nombre de départ, et qui ensuite écrit la table de
multiplication de ce nombre, présentée comme suit (cas où l'utilisateur entre le nombre 7) :
Table de 7 :
7x1=7
7 x 2 = 14
7 x 3 = 21
…
7 x 10 = 70

EX2. Ecrire un algorithme qui demande un nombre de départ, et qui calcule la somme des entiers
jusqu’à ce nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15

EX 3. Ecrire un algorithme qui demande un nombre de départ, et qui calcule sa factorielle.

NB : la factorielle de 8, notée 8 ! vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8

EX 4. Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise
ensuite quel était le plus grand parmi ces 20 nombres :
Entrez le nombre numéro 1 : 12
Entrez le nombre numéro 2 : 14
…
Entrez le nombre numéro 20 : 6
Le plus grand de ces nombres est : 14
Modifiez ensuite l’algorithme pour que le programme affiche de surcroît en quelle position avait été
saisie ce nombre :C’était le nombre numéro 2

EX5. Ecrire un algorithme qui :

- lit d’abord une valeur
- ensuite il va lire successivement 20 nombres.
- enfin il va déterminer combien de fois la première valeur a été saisie (sans compter la première
saisie).

Solutions:
EX1. Le programme est :
Variables i , valeur : Entiers
DEBUT
Lire valeur
POUR i = 1 A valeur
Ecrire valeur & “ X ” & i & “ = ” & valeur * i
FIN POUR
FIN
EX2:Le programme est :
Variables i , valeur , somme : Entiers
DEBUT
Lire valeur
somme 0
POUR i = 1 A valeur
sommesomme + i
FIN POUR
Ecrire “La somme des ” & valeur & “ premiers entiers est : ” & somme
FIN

EX3: Le programme est :

Variables i , valeur , factoriel : Entiers
DEBUT
Lire valeur
factoriel 1
POUR i = 1 A valeur
factorielfactoriel * i
FIN POUR
Ecrire “Le factoriel de ” & valeur & “ est : ” & factoriel
Fin

EX4. Le programme est :

Variables i , a , max , pmax : Entiers
DEBUT
Ecrire « Entrez le nombre numéro 1 »
Lire a
max a
pmax 1
POUR i = 2 A 20
Ecrire « Entrez le nombre numéro » , i
Lire a
SI a > max ALORS
max a
pmax i
FIN
FIN SI
FIN POUR
Ecrire « Le plus grand nombre est : » , max
Ecrire « Sa position est : » ,pmax
EX5.Le programme est :
Variables i , a , b , S : Entiers
DEBUT
Ecrire « Entrez un chiffre : »
Lire a
S0
POUR i = 1 A 20
Ecrire « Entrez un nombre : »
Lire b
SI a = b ALORS
S S + 1
FIN SI
FIN POUR
Ecrire « Le nombre de fois de saisie de » , a , « est : » , S
FIN

I) Types complexes
Les tableaux c’est ce que l’on nomme un type complexe en opposition aux types de données
simples vus précédemment.

Les tableaux
 Un tableau est une variable capable de stocker plusieurs valeurs de même type, accessibles
par leur position dans le tableau.
 Un tableau est un ensemble de valeurs de même type portant le même nom de variable.
Chaque valeur du tableau est repérée par un nombre entier positif appelé indice.
Les tableaux à une dimension
Dimension, type, indice
 La dimension d’un tableau est le nombre de composantes d’un tableau.
 Le type d’un tableau est celui de ses éléments.
 Pour accéder aux éléments d’un tableau, un indice est utilisé. Ce dernier désigne le rang des
éléments.

Déclaration d’un tableau

Syntaxes:
nomDuTableau [nombreElements] : Type
nomDuTableau: désigne le nom du tableau
nombreElements: désigne le nombre d’éléments du tableau. On dit aussi sa taille
Type : c’est le type du tableau autrement dit le type de tous ces éléments
Exemples :
Notes [20] : Réel
noms [10] , prenoms [10] : Chaîne
Nom [10] et prenom [10] sont deux tableaux de 10 éléments de type chaîne.
Notes [20] est un tableau de vingt (20) valeurs réelles.
Pour accéder (en lecture ou en écriture) à la ième valeur d’un tableau, on utilise les syntaxes
suivantes:
nom_tableau[i]  valeur
var1  nom_tableau[i]

Exemple: soit X est un tableau de 10 entiers :

 X (2)  -5 : met la valeur -5 dans la 2ème case du tableau
 En considérant le cas où a est une variable de type Entier, a X [2] : met la valeur de la
2ème case du tableau X dans a, c’est- à- dire 5.
 Lire (X [1]) : met l’entier saisi par l’utilisateur dans la première case du tableau.
 Ecrire (X [1]): affiche la valeur de la première case du tableau
Remarques :
 Un tableau possède un nombre maximal d’éléments défini lors de l’écriture de l’algorithme (les
bornes sont des constantes explicites, par exemple 10, ou implicites, par exemple MAX). Ce
nombre d’éléments ne peut être fonction d’une variable.
 La valeur d’un indice doit toujours être un nombre entier inférieure ou égale au nombre
d’éléments du tableau
EXERCICES

EX4. Soit T un tableau de vingt éléments de types entiers. Ecrire le programme qui permet de
calculer la somme des éléments de ce tableau.
EX 5. Soit T un tableau de N entiers. Ecrire l’algorithme qui détermine le plus grand élément de ce
tableau.
EX 6. Ecrire un programme qui permet de lire 100 notes et de déterminer le nombre de celles qui
sont supérieures à la moyenne.
EX 7. Soit T un tableau de N entiers. Ecrire l’algorithme qui détermine simultanément la position
du plus grand élément et la position du plus petit élément du tableau.
EX 8. Soit T un tableau de N réels. Ecrire le programme qui permet de calculer le nombre des
occurrences d'un nombre X (c'est-à-dire combien de fois ce nombre X figure dans le tableau T).
EX 9. On dispose des notes de 25 élèves ; chaque élève peut avoir une ou plusieurs notes mais
toujours au moins une. Ecrire un programme permettant d’obtenir la moyenne de chaque élève
lorsqu’on lui fournit les notes. On veut que les données et les résultats se présentent ainsi :
Notes de l’élève numéro 1
12
12
-1
Notes de l’élève numéro 2
……
Notes de l’élève numéro 25
15
-1
Moyennes
Elève numéro 1 : 11
……
Elève numéro 25 : 15
Moyenne de la classe : 12.3
Les parties italiques correspondent aux données tapées par l’utilisateur. La valeur -1 sert de critère
de fin de notes pour chaque élève.

Les tableaux dynamiques

Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre d’éléments que devra
comporter un tableau.
Une solution consisterait à déclarer un tableau avec une taille très grande. Cela pourra avoir comme
conséquence soit que cette taille ne nous suffira pas ou qu’une place mémoire immense sera
réservée sans être utilisée.
Afin de surmonter ce problème on a la possibilité de déclarer le tableau sans préciser au départ son
nombre d’éléments. Et c’est, au cours du programme, que l’on va fixer ce nombre via une
instruction de redimensionnement : Redim.

Syntaxe1:
Constante Max valeur
nomTableau[Max] : type

Syntaxe2:
nomTableau[] : type
nb: entier
…
Ecrire("entrer le nombre d'éléments du tableau:")
Lire(nb)
Redim(nomTableau[nb])

Exemple : On veut saisir des notes pour un calcul de moyenne, mais on ne sait pas combien il y
aura de notes à saisir. Le début de l’algorithme sera quelque chose du genre :
Variables
Notes [] : Réel
nb : Entier
DEBUT
Ecrire “Combien y a-t-il de notes à saisir ?“
Lire(nb)
Redim(Notes[nb-1])
…
FIN
Exercices
1. Insertion d'un élément dans un tableau
Soit T un tableau de N éléments. Ecrire un programme qui permet d’insérer un élément x à la
position i du tableau T.
2. Suppression d'un élément du tableau
Soit T un tableau de N éléments. Ecrire un programme qui permet de supprimer un élément x du
tableau.
Solutions
1. Le programme est :
Tableau T () : Entier
Variables i, x, j : Entier
DEBUT
Ecrire « Donnez la dimension du tableau »
Lire N
RedimT (N)
POUR j = 1 A N
Lire T (j)
FIN POUR
Ecrire « Entrez le nombre à insérer »
Lire x
Ecrire « Entrez la position où insérer ce nombre »
Lire i
Redim T (N +1)
j=N
TANT QUE j <i
T (j+1) = T (j)
j=j-1
FIN TANT QUE
T (i) = x

Dans ce programme on a travaillé avec un seul tableau dynamique. On peut aussi travailler avec le
tableau T à dimension fixe et en définir un autre qui recevra tous les éléments de T plus l’élément à
insérer. Le programme dans ce cas est:
T (N) : Entier
Tr (N+1) : Entier
Variables i , x , j , k : Entier
DEBUT
POUR j = 1 A N
Lire T (j)
FIN POUR
Ecrire « Entrez le nombre à insérer »
Lire x
Ecrire « Entrez la position où insérer ce nombre »
Lire i
j=1
k=1
TANT QUE k <N + 1
 SI k �i ALORS
Tr (k) �T (j)
j�j + 1
SINON
Tr (k) = x
FIN SI
k=k+1
FIN TANT QUE

2. Le programme est :
T (N) : Entier
Tr () : Entier
Variables i , x , j : Entier
DEBUT
POUR j de 1 A N
Lire T (j)
FIN POUR
Ecrire « Entrez le nombre à supprimer »
Lire x
j0
POUR i de 1 A N
SI T (i) x ALORS
j j + 1
ReDim Tr (j)
Tr (j) = T (i)
FIN SI
FIN POUR

Dans ce programme on a considéré deux tableaux, le tableau T à dimension fixe et le tableau Tr

dynamique.
Il est aussi possible de travailler avec un seul tableau dynamique.
Tableau T () : Entier
Variables x, j , k , N : Entiers
DEBUT
Ecrire « Donnez la dimension du tableau »
Lire N
RedimT (N)
POUR j = 1 A N
Lire T (j)
FIN POUR
Ecrire « Entrez le nombre à supprimer »
Lire x
j=1
TANT QUE j < N
SI T (j) = x ALORS
 POUR k = j A N - 1
T (k) = T (k + 1)
FIN POUR
N N – 1
ReDimT (N)
SINON
jj + 1
FIN SI
FIN TANT QUE

6.3. Les tableaux multidimensionnels

Les tableaux à deux dimensions (les matrices)
Un tableau à deux dimensions (appelé aussi Matrice) est constitué de plusieurs lignes et de
plusieurs colonnes.
Déclaration:

Tab[i, J] : type
Accès Aux éléments

Soit la matrice: tab[3,2] : Réel

On accède (en lecture ou en écriture) à la (ième , jème) valeur d'un tableau en utilisant la syntaxe
suivante :

En Ecriture:
tab[2,1]  -1.2 // met la valeur -1.2 dans la case d'indices 2,1 du tableau
En Lecture:
En considérant le cas où a est une variable de type Réel:
a  tab[2,1] // met -1.2 dans la variable a
tab[2,1]  tab[1,1] // copie le contenu de la case d'indices (1, 1) dans la case d'indices (2,1)

Operations sur les matrices

Parcourir une matrice
Pour parcourir un tableau à deux dimensions, on utilise deux indices i et j: le premier pour les lignes
et le deuxième pour les colonnes

Algorithme Matrices
Variables:
i, j, val en Entier
Tab: Tableau[nbl,nbcol] en Entier
Début
Val ← 1
//remplissage
Pour i ← 0 { nbl
Pour j ← 0 { nbcol
Tab [i][j] ← Val
Val ← Val + 1
FinPour
FinPour
//Affichage
Pour i ← 0 { 1
Pour j ← 0 { 2
Ecrire Tab [i][j]
FinPour
FinPour
Fin
Exercices
1. Considérons le programme suivant :
Variables:
X (2 , 3) : Entier
i , j , val : Entiers
DEBUT
val1
POUR i = 1 A 2
POUR j = 1 A 3
X (i , j) val
valval + 1
FIN POUR
FIN POUR
POUR i = 1 A 2
POUR j = 1 A 3
Ecrire X (i , j)
FIN POUR
FIN POUR
a. Que produit l’exécution de ce programme.

b. que produira ce programme si l’on remplace les dernières lignes par :

POUR j = 1 A 3
POUR i = 1 A 2
Ecrire X (i , j)
FIN POUR
FIN POUR
2. Quel résultat fournira ce programme :
Variables:
X (4 , 2) : Entier
k , m : Entiers
DEBUT
POUR k = 1 A 4
POUR m = 1 A 2
X (k , m) k + m
FIN POUR
FIN POUR
POUR k = 1 A 4
POUR m = 1 A 2
Ecrire X (k , m)
FIN POUR
FIN POUR
Fin

1- LES STRUCTURES
Imaginons que l’on veuille afficher les notes d’une classe d’élèves par ordre croissant avec les noms
et prénoms de chaque élève. On va donc utiliser trois tableaux (pour stocker les noms, les prénoms
et les notes). Lorsque l’on va trier le tableau des notes il faut aussi modifier l’ordre les tableaux qui
contiennent les noms et prénoms. Mais cela multiplie le risque d’erreur. Il serait donc intéressant
d’utiliser ce qu’on appelle les structures.
Les structures contrairement aux tableaux de stocker un ensemble fini d’éléments de type
éventuellement différents.
A la différence des tableaux, il n’existe pas par défaut de type structure c'est-à-dire qu’on ne peut
pas déclarer une variable de type structure. Ce qu’on peut faire c’est de construire toujours un
nouveau type basé sur une structure et après on déclare des variables sur ce nouveau type.

a. Déclaration:
TYPES:
STRUCTURE NomDuType
attribut1 : Type-1
attribut2 : Type-2
...
Attributn : Type-n
FinStructure
Le type d’un attribut peut être :
 Un type simple
 Un type complexe
 Un tableau
 Un type basé sur une structure

Exemple1 :
STRUCTURE Etudiant
Nom: chaine
prenom : chaine
note : reel
FinStructure

Dans cet exemple on a construit un type Etudiant basé sur une structure. Cette structure a trois
attributs (on dit aussi champ) : nom, prenom et note.

Exemple2 :
STRUCTURE TypeDate
jour : entier
mois : entier
annee : entier
FinStructure

Dans ce deuxième exemple, on a construit un type appelé typeDate basé sur une structure. Cette
structure a aussi trois attributs : jour, mois et annee.
Après on peut déclarer des variables basées sur ce type:
b. Utilisation: déclaration de variables structurées
Exemple1 :
Etud : Etudiant
Etud est une variable de type Etudiant.
Une variable structurée est appelée aussi un Enregistrement.

c. Accès aux attributs d'un Enregistrement:

Pour accéder aux attributs d’une variable structurée, on suffixe le nom de la variable d’un point " . "
suivi du nom de l’attribut.
En Ecriture:
NomEnreg.attribut  valeur
Où
Lire(NomEnreg.attribut)
En Lecture:
Var1  NomEnreg.attribut
Où
Ecrire (NomEnreg.attribut)
Exercices
1. Définissez la structure " Stagiaire " constituée des champs suivants :
Nom Chaîne
Prénom  Chaîne
Datenais Structure
Le champ " Datenais " est aussi une structure dont les champs sont :
Jour Entier
Mois Entier
Année Entier
Ecrivez ensuite l’algorithme qui permet de lire et après afficher le nom, prénom et date de
naissance d’un stagiaire.
2. On souhaite gérer les notes d’un étudiant dont les caractéristiques sont:
nom chaîne
prenom chaîne
note Réel
moyenne  reél

Ecrire l’algorithme qui permet de lire les informations d’un étudiant (nom, prénom et notes), de
calculer sa moyenne et d’afficher à la fin un message sous la forme suivante :
" La moyenne de l’étudiant Dinar Youssef est : 12.45 "
où " Dinar " et " Youssef " sont les noms et prénoms lus et 12.45 est la moyenne calculée.
3. Modifier l’algorithme de l’exercice précédent de façon que l’on puisse gérer les notes de 50
étudiants.

SOLUTION

1. L’algorithme est :
Algorithme AlgoStagiaires
Types:
structure Date
Jour : entier
Mois :entier
Annee : entier
EndStructure

structure Stagiaire
Nom :chaine
Prenom :chaine
Datenais : Date
EndStructure
Variables:
stag : Stagiaire

DEBUT
 Ecrire (" Entrez les informations du stagiaire ")
Ecrire (" Entrez le nom ")
Lire (stag.Nom)
Ecrire (" Entrez le prénom ")
Lire (stag.Prenom)
Ecrire (" Entrez le jour de naissance ")
Lire (stag.Date.Jour)
Ecrire (" Entrez le mois de naissance ")
Lire (stag.Date.Mois)
Ecrire " Entrez l’année de naissance "
Lire (stag.Date.Annee)
Ecrire (" Le nom du stagiaire est : " , stag.Nom)
Ecrire (" Son prénom est : " , stag.Prenom)
Ecrire ("Sa date de naissance est :", stag.Date.Jour , "/", stag.Date.Mois, "/", stag.Date.Annee)
Fin

2. L’algorithme est :

Algorithme Algo2
STRUCTURE Etudiant
Nom : Chaîne
Prenom : Chaîne
Note (3) : Réel
Moyenne : Réel
FIN STRUCTURE
Variables:
i : Entier
som : Réel
etud : Etudiant
DEBUT
Ecrire (" Entrez les informations de l’étudiant ")
Ecrire (" Entrez le nom ")
Lire (etud.Nom)
Ecrire (" Entrez le prénom ")
Lire (etud.Prenom)
Ecrire (" Entrez la première note ")
Lire (Etud.Note (1))
Ecrire (" Entrez la deuxième note ")
Lire (etud.Note (2))
Ecrire (" Entrez la troisième note ")
Lire (etud.Note (3))
som ← 0
POUR i = 1 A 3
som ← etud.Note (i)
FIN POUR
etud.Moyenne = som / 3
Ecrire ("La moyenne de l’étudiant " , etud.Nom , " " , etud.Prenom , " est : " , etud.Moyenne)
Fin

3. L’algorithme est :

STRUCTURE Etudiant
Nom : Chaîne
Prenom : Chaîne
Note(3) : Réel
Moyenne : Réel
FIN STRUCTURE
Variables:
i , j : Entier
som : Réel
etud(50) : Etudiant
DEBUT
Ecrire (" Entrez les informations des étudiants ")
POUR j = 1 A 50
Ecrire (" Entrez le nom ")
Lire (etud(j).Nom)
Ecrire (" Entrez le prénom ")
Lire (etud(j).Prenom)
Ecrire (" Entrez la première note ")
Lire (etud(j).Note (1))
Ecrire (" Entrez la deuxième note ")
Lire (etud(j).Note (2))
Ecrire (" Entrez la troisième note ")
Lire (etud(j).Note (3))
som ← 0
POUR i = 1 A 3
som ← etud(j).Note (i)
FIN POUR
etud (j).Moyenne = som / 3
FIN POUR
POUR j = 1 A 50
Ecrire ("La moyenne de l’étudiant " , etud(j).Nom , " " , etud(j).Prenom , " est : " ,
etud(j).Moyenne)
FIN POUR
FIN

d. L'imbrication d'enregistrements
Supposons que dans le type personne, nous ne voulions plus l'âge de la personne, mais sa date de
naissance. Une date est composée de trois variables (jour, mois, année) indissociables. Une date
correspond donc à une entité du monde réel qu'on doit représenter par un type enregistrement à 3
champs.
Si on déclare le type date au préalable, on peut l'utiliser dans la déclaration du type personne pour
le type de la date de naissance.
Un type structuré peut être utilisé comme type pour des champs d'un autre type structuré :
Types:
Structure typeDate
jour : entier
mois : chaîne
année : entier
FinStucture
Structure personne
nom : chaîne
dateNais : typeDate
FinStucture

Pour accéder à l'année de naissance d'une personne, il faut utiliser deux fois l'opérateur point '.' :
pers1. dateNais.année
Il faut lire une telle variable de droite à gauche : l'année de la date de naissance de la personne 1.
Un produit est livré par un seul fournisseur. Un fournisseur est caractérisé par son code, sa raison
sociale et son numéro de téléphone.

Types:
Structure adresse
num : entier
rue : chaîne
cp : chaîne
ville : chaîne
FinStruct
Structure fournisseur
code_frs : chaine
raison_sociale : chaine
adr_frs : adresse
tel : chaine
FinStruct
Structure Produit
code: chaîne
lib: chaîne
paht: réel
pvht: réel
txtva: réel
frs: fournisseur
FinStruct
Variables:
P1 : produit
Pour afficher le numéro de téléphone du fournisseur du produit P1: p.frs.tel
Ecrire ("téléphone du fournisseur de ", p1.lib, " : ", p1.frs.tel

e. Les tableaux d'enregistrement (ou tables)

Il arrive souvent que l’on veuille traiter non pas un seul enregistrement mais plusieurs. Par
exemple, on veut pouvoir traiter un groupe de personne. On ne va donc pas créer autant de
variables du type personne qu’il y a de personnes. La solution consiste à créer un tableau
regroupant toutes les personnes du groupe. Il s’agit alors d’un tableau d’enregistrements.
 Déclaration:
Il est possible de déclarer un tableau d’éléments de type Etudiant:
tEtuds[20] : Etudiant
tEtuds [1] : représente le premier étudiant

Exemple:
Affecter la chaine "Alami" à l'attribut (champ) nom du premier étudiant :
tEtuds [1].nom = "Alami"

Accès à un Enregistrement du tableau

On accède à un enregistrement par son indice dans le tableau.
Ainsi, groupe[2] : représente la deuxième personne du groupe.
Exemple:
Per1: personne; // déclaration d'un enregistrement personne
Groupe[2] per1
Où
Per1  Groupe[2]

Accès aux champs d'un Enregistrement du tableau

Chaque élément du tableau est un enregistrement, contenant plusieurs variables de type différent.
Pour accéder au champ "champ1" de l'enregistrement d'indice "j" du tableau "tab", on utilise la
syntaxe:
Tab[j].champ1  valeur // accès en écriture
Où
Var1  Tab[j].champ1 // accès en lecture

Attention :
 groupe[2].nom : représente le champ nom de la 3ème personne du groupe.
 Mais, groupe.nom[2] n'est pas valide.
 Pour accéder au nom de la 3ème personne du tableau, il faut écrire : groupe [2].nom

Exemple:
Algorithme AlgoPersonnes
Constantes:
NP 20 // nombre de personnes du groupe
Type
Structure personne
nom: chaîne
age: entier
FinStruct
Variables
 Groupe [NP] : personnes
Per1, Per2: personne;
Groupe[10] : personne
Debut
//Accès en Ecriture:
Per1.nom  "Idrissi"
Per1.age  20
//Où
Groupe[2] .nom  "ALAOUI"
Groupe[2].age  18
//Accès en Lecture:
Ecrire ("nom de Per1 :", Per1.nom )
Ecrire ("Age de Per1 :", Per1.age )
//Où
Ecrire ("le nom de la 3eme personne du groupe est :", Groupe[2] .nom )
Ecrire ("l'Age de la 3eme personne du groupe est :", Groupe[2] .age)
Fin

Les sous-programmes
I) Introduction
Un sous-programme est, comme son nom l'indique, est un petit programme identifié par un nom,
réalisant un traitement particulier et qui s'exécute à l'intérieur d'un autre programme.

Les sous-programmes sont utilisés pour deux raisons:

 Quand un même traitement doit être réalisé plusieurs fois dans un programme (ou qu'il est
utilisé dans plusieurs programmes): on écrit un sous-programme pour ce traitement et on
l'appelle à chaque endroit où l'on en a besoin. On évite ainsi de réécrire plusieurs fois le
code du traitement.

 Pour organiser le code, améliorer la conception et la lisibilité des gros programmes. En effet,
le découpage en sous-programmes permet de traiter séparément les difficultés.

Remarque:
La majorité des langages de programmation, possèdent des sous-programmes qui ont déjà été
écrits et peuvent être utilisés directement par les programmeurs. Ces sous programmes sont
appelés: "sous-programmes prédéfinis" ou standards.
C'est le cas par exemple des sous-programmes permettant de faire des calculs mathématiques
(racine carrée, exposant, …).
Il existe deux sortes de sous-programmes : les procédures et les fonctions.

 Les procédures

Une procédure est un ensemble d'instructions regroupées sous un nom, qui réalise un traitement
particulier dans un programme lorsqu'on l'appelle.
Comme un programme, une procédure possède un nom, des variables, des instructions, un début
et une fin.
Contrairement à un programme, un sous-programme ne peut pas s'exécuter indépendamment d'un
autre programme.
Définition (implémentation)

Procédure nomProc( nb : entier)

Variables
Var1: type
Début
Bloc d'instructions
FinProc

Exemple:
Procédure affichant une ligne de 10 étoiles puis retourne à la ligne.
Procédure ligneEtoiles( )
Variables:
 i : entier
Début
Pour i  1 jusqu'à 10 Faire
Afficher ("*")
FinPour
Afficher '\n'
FinProc

Appel d'une procédure

Pour exécuter une procédure dans un programme, il suffit de l'appeler: c'est-à-dire d'indiquer son
nom suivi de parenthèses: nomProcedure().
Exemple:

Algorithme RectangleDetoiles Procédure ligneEtoiles( )

Variables Variables
i : entier
nlignes: entier Début
Pour i de 1 à 10 Faire
cpt : entier Ecrire( '*')
FinPour
Début Ecrire( '\n')
FinProc
Ecrire("programme rectangle d'étoiles".
Ecrire "entrer le nombre de lignes: "
Lire (nlignes)
Pour cpt de 1 jà nlignes Faire
ligneEtoiles( ) // appel
FinPour
Fin

Lorsque le processeur rencontre l'appel d'une procédure, il arrête momentanément l'exécution du

programme appelant pour aller exécuter les instructions de la procédure. Quand il a terminé
l'exécution de la procédure, le processeur reprend l'exécution du programme appelant là où il s'était
arrêté.
NB:
Une procédure peut être appelée soit par un programme, soit par un autre sous-programme. Les
appels de sous-programmes peuvent s'imbriquer autant de fois qu'on le désire.

Notions de variables locales et de paramètres

Les variables déclarées dans une procédure ne sont pas utilisables dans le programme appelant et
inversement, les variables déclarées dans le programme appelant ne sont pas utilisables dans les
procédures.
Chaque programme et sous-programme à son propre espace de variables, inaccessible par les
autres. On dit que les variables sont LOCALES.

Pour communiquer en eux (envoyer et recevoir des données), le programme principal et les
procédures utilisent des paramètres.
Un paramètre est une variable particulière qui sert à la communication entre le programme
appelant et le sous-programme.
Un paramètre peut donc être utilisé pour passer des données à un sous-programme, ou pour
retourner un résultat produit par ce dernier.

Exemple :

Dans notre exemple, nous allons mettre le nombre d'étoiles par lignes en paramètre.

Pour cela, nous indiquons entre parenthèses la déclaration du paramètre (qui est une variable
locale de la procédure), précédé du mot clé "donnée" pour indiquer que le paramètre constitue une
donnée du traitement réalisé par la procédure. La valeur de cette donnée est communiquée à
l'appel, par le programme appelant.

Procédure ligneEtoile (donnée nbre : entier ) //sous-programme; nbre est un paramètre formel
Variables
cpt : entier
Début
Pour cpt 1 jusqu'à nbre Faire
Ecrire( '*')
FinPour
Ecrire( '\n')
FinProc

Programme RectangleEtoile //programme appelant

Variables
nlignes, netoiles : entier //nombre de lignes et nombre d'étoiles par ligne
i : entier
Début
Ecrire( "Ce programme dessine un rectangle d'étoiles.")
Ecrire "Combien voulez-vous d'étoiles par ligne<--"
Lire (netoiles)
Ecrire ("Combien voulez-vous de lignes: ")
Lire (nlignes)
Pour i de 1 à nlignes Faire
ligneEtoile(netoiles) // netoiles est appelé "parametre effectif"
 FinPour
Fin

Passage de paramètres par valeurs (donné)

Lors de l'appel de la procédure, la valeur de la variable "netoiles" passée en argument est copiée
dans le paramètre formel "nombre".

La procédure n'utilise pas directement la variable "netoiles" : elle utilise sa valeur, qu'elle a recopiée
dans sa propre variable-paramètre "nombre".

Remarque:

Lorsqu'il y a plusieurs paramètres dans la définition d'une procédure, il faut absolument qu'il y en
ait le même nombre à l'appel et que l'ordre soit respecté (car la copie se fait dans l'ordre).

Les paramètres formels et paramètres réels

Les paramètres placés dans la définition d'une procédure sont appelé paramètres formels. Ils
servent à décrire le traitement à réaliser par la procédure indépendamment des valeurs traitées.
Les paramètres formels sont des variables locales à la procédure, et à ce titre ils sont déclarés dans
l'en-tête de la procédure.

Les paramètres placés dans l'appel d'une procédure sont appelés paramètres réels ou effectifs.
Lorsqu'ils sont de type "donnée", ils contiennent effectivement les valeurs sur lesquelles sera
effectué le traitement de la procédure. Lors de l'appel, leur valeur est recopiée dans les paramètres
formels correspondants.
Un paramètre effectif en donnée peut être soit une variable du programme appelant, soit une
valeur littérale, soit le résultat d'une expression.

1. Passage de paramètres par références (paramètres de type résultats)

Lors du passage par référence, La valeur du paramètre formel résultat est copiée dans la variable
passée en paramètre dans l'appel (le paramètre effectif). La valeur initiale du paramètre effectif (à
l'appel) n'a donc aucune importance ; elle est même souvent indéterminée. La procédure se charge
de lui affecter une valeur.
Exemple 1:

Procédure qui permet de Lire les valeurs (c'est-à-dire d'initialiser) un tableau de 30 réels. Cette
procédure n'a qu'un paramètre : le tableau. C'est un résultat de la procédure.

Procédure Saisietab( Résultat untab[30] de réels)

Variables
i : entier
debut
Pour i allant de 1 à 30 Faire
 Lire untab[i]
FinPour
/*à la fin de la boucle, le tableau est rempli*/
FinProc

Exemple 2:
Procédure qui retourne le minimum et le maximum d'un tableau de 30 réels. Le tableau est une
donnée, le minimum et le maximum sont des résultats.

Procédure minmax (donnée unTab[30] : réels Résultats mini, maxi : réels)

Variables
i : entier
Début
Mini unTab [0]
Maxi unTab [0]
Pour i allant de 1 à 29 Faire
Si unTab [i]< mini Alors
Mini unTab [i]
FinSi
Si unTab [i]> maxi Alors
Maxi unTab [i]
FinSi
FinPour
/*A la sortie de la boucle, mini et maxi contiennent respectivement la valeur du
minimum et la valeur du maximum*/
FinProc

Ces procédures peuvent être appelées dans un programme qui saisit 30 notes et affiche la note
maximale et la note minimale :

Algorithme notes;
Variables
tabnotes [30] : réels;
noteMin, noteMax : réels ;
Début
Ecrire ("Veuillez Saisir les 30 notes");
Ecrire(tabnotes);
minmax(tabnotes, noteMin, noteMax);
Ecrire ("La note la plus haute est ", noteMax, "et la note la plus basse est ", noteMin)
Fin

Remarque:
Les deux procédures utilisent toutes les deux une variable appelée i. Mais i correspond à deux
variables différentes. Le i de la première procédure ne correspond pas à la même variable que le i
de la deuxième procédure : chaque sous-programme a son espace mémoire propre.

Paramètres donnée-résultat (Entrée-Sortie)

Les paramètres données-résultats correspondent à des données qui doivent être modifiées par une
procédure.
A l'appel:
 La valeur du paramètre effectif est copiée dans le paramètre formel de la procédure.
 La procédure utilise cette valeur pour la modifier.
 A la fin de la procédure, la nouvelle valeur du paramètre formel est recopiée dans le
paramètre effectif du programme appelant.

Exemple :

Procédure qui prend pour paramètre un tableau de 10 entiers non trié et qui le renvoie trié en ordre
croissant. Le tableau est à la fois une donnée et un résultat de la procédure.

Procédure tabtri( donnée-résultat letab [10]: entier)

Variables
échange : booléen
i, fin : entier //indices (fin = dernier indice traité)
temp : entier //variable servant à l'échange
Début
Echangefaux
Fin10 -1
Répéter
Tantque i < fin Faire
Si letab[i] > letab[i+1] Alors
Echangevrai
Templetab[i]
letab[i]letab[i+1]
letab[i+1]letab[i]
FinSi
Ii + 1
FinTantQue
fin fin – 1
Jusqu'à (non échange)
// à la sortie de la boucle, il n'y a plus d'échanges possibles, donc le tableau est trié
FinProc

Algorithme trierTableau

Variables
 montablo[10] : entier;
i : entier

Début

Ecrire( "Tapez 10 valeurs entières"

Pour i de 0 à 9 Faire
Lire montab[i]
FinPour
tabtri(montab)
Ecrire "Tableau trié par ordre croissant"
Pour i de 0 à 9 Faire
Ecrire montab[i]
FinPour

Fin

Procédures retournant plusieurs résultats

Une procédure peut renvoyer plusieurs résultats au programme appelant à travers des paramètres
résultats (sorties). Elle peut aussi modifier la valeur d'un paramètre : ce paramètre doit alors être
de type "donnée-résultat".

Résumé des différents types de paramètres :

Un paramètre de procédure peut être de type:

 Donnée (Entrée): la valeur du paramètre effectif est utilisée dans la procédure et elle reste
inchangée ;

 Résultat (Sortie): la valeur initiale du paramètre effectif est ignorée par la procédure. La
valeur finale du paramètre formel résultat est copiée dans le paramètre effectif
correspondant (qui doit obligatoirement être une variable de même type) ;
 Donnée-Résultat(Entrée-Sortie): La valeur initiale du paramètre effectif est utilisée par la
procédure qui peut la modifier. Au retour d'appel, la nouvelle valeur est recopiée dans le
paramètre effectif correspondant (qui est obligatoirement une variable).

Les fonctions

Les fonctions sont des sous-programmes qui retournent un et un seul résultat au programme
appelant.
De ce fait, les fonctions sont appelées pour récupérer une valeur, alors que les procédures ne
renvoient aucune valeur au programme appelant.
L'appel d'une fonction doit obligatoirement se trouver à l'intérieur d'une instruction (affichage,
affectation, …) qui utilise sa valeur.
Le résultat d'une fonction doit obligatoirement être retourné au programme appelant par
l'instruction Retourner.
Syntaxe:

Fonction nomFonction(liste des paramètres) : typeDeRetour

Variables
valeurAretourner : typeDeRetour
Début
Instruction obligatoire //traitement
valeurAretourner  valeur ou expression
Retourner valeurAretourner
FinFonction

Exemple :
Fonction factorielle (n : entier): entier /*Cette fonction retourne la factorielle du
nombre n passé en paramètre*/
Variables
i : entier
 fact : entier
Début
fact1
Si (n !=.0) Alors
Pour i de 1 à n Faire
Fact  fact * n
FinPour
FinSi
Retourner fact
FinFonction

Fonction saisie_nbre_positif( ) : entier

Variables
nb_saisi :entier
Début
Ecrire("Veuillez entrer un nombre positif")
Lire (nb_saisi)
Tantque nb_saisi < 0 Faire
Ecrire "Erreur. Veuillez Saisir un nombre supérieur à 0!"
Lire nb_saisi
FinTQ
Retourner nb_saisi
FinFonction

Exemple de programme appelant utilisant ces deux fonctions :

Algorithme affiche_factorielle
Variables
nombre: entier
rep : chaîne
Début
Répéter
Nombre saisie_nb_positif( ) // Appel de la fonction saisie_nb_positif et
//affectation de sa valeur retournée à la variable nombre
Ecrire( "La factorielle de ", nombre, " est ", factorielle(nombre)
Ecrire("Voulez-vous recommencez (oui/non)");
Lire (rep)
Jusqu'à (rep = "non")
Ecrire ("Fin")
Fin

Exercices d'application:
Exercice 1

Ecrire l’algorithme de la fonction définie ci-dessous :

Fonction Puissance(A, n : Entier)

Type du résultat renvoyé : réel

Objectif : calcul de la puissance de n de A. N avec A positif et n quelconque

utilisation :

Puissance(2,3) donne 8

Puissance(3,2) donne 9

Exercice 2

Ecrire l’algorithme de la fonction suivante permettant de déterminer si une année est bissextile.

Fonction Bissextile(Année : Entier)

Type du résultat renvoyé : Booléen

Objectif : renvoie Vrai si l’année donnée en paramètre est bissextile et Faux sinon

Exemple d’utilisation : Bissextile(1996) renvoie Vrai

Résumé des différences entre fonctions et procédures :

Les fonctions ne peuvent avoir que des Les procédures peuvent avoir des paramètres
paramètres données. résultats, données ou données-résultats.

Les fonctions ne peuvent communiquer qu'un Les procédures peuvent communiquer de 0 à

seul résultat au programme appelant à travers plusieurs résultats au programme appelant à
une valeur de retour (et non à travers un travers des paramètres résultats ou données-
paramètre) résultats. La valeur de ces résultats est affectée
aux paramètres effectifs correspondant (qui
doivent obligatoirement être des variables du
programme appelant).

Elle s'appelle à l'intérieur d'une instruction. L'appel d'une procédure représente une
L'instruction utilise la valeur retournée par la instruction en elle-même. On ne peut pas
fonction. appeler une procédure au milieu d'une
instruction

Les fonctions prédéfinies

1. Les fonctions de texte (Les fonctions de chaines de caractère)
Permettent de manipuler des chaînes de caractères. Nous avons déjà vu qu’on pouvait
facilement concaténer (joindre) deux chaînes l’une à l’autre avec l’opérateur de concaténation &.
Mais ce que nous ne pouvions pas faire, et qui va être maintenant possible, c’est pratiquer des
extractions de chaînes, rechercher des chaines….
Tous les langages, proposent des fonctions de traitement de chaines plus ou moins
nombreuses:
 Len(chaîne) ou longueur(ch): renvoie le nombre de caractères d’une chaîne.
 Mid(chaîne, n1, n2) ou Copie(chaîne, n1, n2): renvoie un extrait de la chaîne,
commençant au caractère n1 et comprenant n2 caractères de long.
Ce sont les deux seules fonctions de chaînes réellement indispensables. Cependant, les langages
proposent également :
 Left(chaîne,n) : renvoie les n caractères les plus à gauche dans chaîne.
 Right(chaîne,n) : renvoie les n caractères les plus à droite dans chaîne.
 Trouve(chaîne1, chaîne2) : renvoie un nombre correspondant à la position de chaîne2
dans chaîne1. Si chaîne2 n’est pas comprise dans chaîne1, la fonction renvoie zéro.
 concat(ch1, ch2): retourne une chaîne formée par la concaténation de ch1 et de ch2. La
chaîne résultat est formée de ch1 suivi de ch2.
 comp(ch1, ch2): compare deux chaînes de caractères en utilisant l'ordre des
caractères définis par le code ASCII. Elle fournit une valeur entière:
o positive si ch1 > ch2.
o 0 si ch1 = ch2. si les deux chaînes contiennent exactement les mêmes caractères.
o négative si ch1 < ch2
 Asc("caract"): renvoie le code ASCII correspondant au caractère caract.
 Chr(nb): renvoie le caractère correspondant au code Ascii nb.
 recherche(ch1, ch2) ou Trouve(chaîne1,chaîne2)
renvoie un nombre correspondant à la position de la première occurrence complète de la
chaîne ch2 dans la chaîne ch1. Si la chaîne ch2 n'est pas comprise dans la chaîne ch1, la
fonction renvoie zéro.
recherche(ch1, caract) ou Trouve(ch1, caract)
renvoie un nombre correspondant à la position de la première occurrence du caractère
"caract" dans la chaîne ch1. Si le caractère "caract" n'est pas compris dans la chaîne ch1, la
fonction renvoie zéro.

Exemples :

N = Len("Bonjour, ça va")  N vaut 16

N = Len("")  N vaut 0
ch = Mid("Zorro is back", 4, 7)  ch vaut "ro is b"
ch = Mid("Zorro is back", 12, 1) ch vaut "c"
Ch = Copie("Bonjour",4,4)  ch vaut "our"
ch = Left("Et pourtant…", 8)  ch vaut "Et pourt"
ch = Right("Et pourtant…", 4)  ch vaut "t…"
pos = Trouve("Un pur bonheur", "pur")  vaut 4
pos = Trouve("Un pur bonheur", "techno")  vaut 0.
N = Asc('A')  N vaut 65
Caract = Chr(66)  caract vaut 'B'
Trouve("Un pur bonheur", "pur") vaut 4
Trouve("Un pur bonheur", "techno") vaut 0
Ch = concat("Bonjour"," Monsieur")  ch vaut "Bonjour Monsieur"
comp("bonjour", "monsieur"): retourne une valeur négative.
Pos = recherche("bonjour monsieur","jour")  pos vaut 4

3. Quelques fonctions numériques:

 Partie Entière
Ent(nbreReel): retourne la partie entière d’un nombre.
Exemple:
Après : A ← Ent(3,228) A vaut 3
 Modulo(nb1, nb2) : retourne le reste de la division de nb1 par nb2.
Exemple :
A ← Mod(10, 3) A vaut 1 car 10 = 3*3 + 1
B ← Mod(12, 2) B vaut 0 car 12 = 6*2
C ← Mod(44, 8) C vaut 4 car 44 = 5*8 + 4
 Génération de nombres aléatoires
Alea(): génère un nombre réel aléatoire compris entre 0 et 1 bornes exclues.
Pour obtenir une valeur entière comprise entre min et max (avec min < max), on utilise la formule
suivante :
Ent((max-min+1)*Alea() + min)
Exemple :

Générer un nombre aléatoire X compris entre 5 et 10.

X ← Ent(6 * Alea() + 5)
Cette fonction existe dans tous les langages et produit le résultat suivant :
nb ← Alea()  0 =< nb < 1

Remarque:
On peut à l'aide de Alea() générer n’importe quel nombre compris entre 0 et un nombre nb en
multipliant Alea() par nb:
Exemple:
Générer un nombre entre 1,35 et 1,65. L'intervalle mesure 0,30 de large. Donc : 0 =<
Alea()*0,30 < 0,30
Il suffit alors d’ajouter 1,35 pour obtenir la valeur voulue:
nb ← Alea()*0,30 + 1,35
nb: aura une valeur comprise entre 1,35 et 1,65.