Algorithmique 1

Table des matières
Table des matières i
1 Introduction
1
1.1 Notion d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Les caractéristiques d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 De l’algorithme au programme . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Structure générale d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.1 Les différentes méthodes de représentation d’un algorithme . . . . . . 4
1.4.1.1 Le pseudo-langage . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.1.2 L’organigramme . . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.1.3 Le Structogramme . . . . . . . . . . . . . . . . . . . . . . . 4
1.4.2 Structure d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Les types de données simples et les actions élémentaires

7
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Les variables et les constantes . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Les types simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4 Les expressions arithmétiques et logiques . . . . . . . . . . . . . . . . . . . . 11
2.4.1 Les expressions arithmétiques . . . . . . . . . . . . . . . . . . . . . . 11
2.4.2 Les expressions logiques . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.3 Evaluation d’une expression . . . . . . . . . . . . . . . . . . . . . . . 12
2.5 Les instructions élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5.1 L’instruction de déclaration . . . . . . . . . . . . . . . . . . . . . . . 12
2.5.2 L’instruction d’affectation . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5.3 L’instruction de lecture . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5.4 L’instruction d’écriture . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3 Les structures conditionnelles 16

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 la structure si. . .alors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
i
TABLE DES MATIÈRES
3.2.1 Le conditionnel simple . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.2.2 Le conditionnel généralisé . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.3 Le conditionnel imbriqué . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 La structure selon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4 Les structures itératives 22

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2 La boucle Pour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.3 La boucle Tant que . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.4 La boucle Répéter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5 Les tableaux 30
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.2 Les vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.2.1 Déclaration d’un tableau de type Vecteur . . . . . . . . . . . . . . . . 31
5.2.2 L’accès à un élément du vecteur . . . . . . . . . . . . . . . . . . . . . 32
5.2.3 Le saisie et l’affichage d’un vecteur . . . . . . . . . . . . . . . . . . . 32
5.2.4 La recherche d’un élément dans un vecteur . . . . . . . . . . . . . . . 33
5.2.4.1 La recherche séquentielle . . . . . . . . . . . . . . . . . . . 34
5.2.4.2 La recherche dichotomique . . . . . . . . . . . . . . . . . . 34
5.2.5 Le trie d’un vecteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3 Les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.1 Déclaration d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3.2 L’accès à un élément d’une matrice . . . . . . . . . . . . . . . . . . . 39
5.3.3 Le saisie et l’affichage d’une matrice . . . . . . . . . . . . . . . . . . 40
5.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6 Les chaînes de caractères 42

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
6.2 Opérations sur les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . 43
6.2.1 La lecture et L’affichage d’une chaîne . . . . . . . . . . . . . . . . . . 43
6.2.2 Les fonctions prédéfinies sur les chaînes . . . . . . . . . . . . . . . . . 43
6.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
7 Les enregistrements 47
7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.2 Déclaration d’une variable de type enregistrement . . . . . . . . . . . . . . . . 48
7.3 Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
7.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Hana JOUINI page ii Algorithmique Niveau 1

TABLE DES MATIÈRES
8 Les procédures et les fonctions 53

8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.2 Analyse et décomposition des problèmes . . . . . . . . . . . . . . . . . . . . . 54
8.3 Les procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.3.1 Structure d’une procédure . . . . . . . . . . . . . . . . . . . . . . . . 55
8.3.2 Utilisation d’une procédure . . . . . . . . . . . . . . . . . . . . . . . . 55
8.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.4.1 Structure d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . 56
8.4.2 Utilisation d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . 56
8.5 La Portée des Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.6 Comparaison entre les procédures et les fonctions . . . . . . . . . . . . . . . . 57
8.7 La récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Hana JOUINI page iii Algorithmique Niveau 1

Table des figures
1.1 modélisation d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2 de l’algorithme au programme . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 structure d’un structogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3.1 modélisation de la structure conditionnelle simple . . . . . . . . . . . . . . . . 17

3.2 modélisation de la structure conditionnelle généralisée . . . . . . . . . . . . . 18
4.1 Modélisation de la boucle Pour . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.2 Modélisation de la boucle Tant que . . . . . . . . . . . . . . . . . . . . . . . . 25
4.3 Modélisation de la boucle Répeter . . . . . . . . . . . . . . . . . . . . . . . . 26
8.1 Analyse descendante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
iv
Liste des algorithmes
2.1 Algorithme moyenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.1 Algorithme valeur absolue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2 Algorithme note . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Algorithme Robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.1 Algorithme affichage des N premiers entiers (boucle Pour) . . . . . . . . . . . 25
4.2 Algorithme affichage des N premiers entiers (boucle Tant que) . . . . . . . . . 26
4.3 Algorithme affichage des N premiers entiers (boucle Répéter) . . . . . . . . . . 27
4.4 Algorithme moyenne avec la boucle Pour . . . . . . . . . . . . . . . . . . . . 27
4.5 Algorithme moyenne avec la boucle Tant que . . . . . . . . . . . . . . . . . . 28
4.6 Algorithme moyenne avec la boucle Répéter . . . . . . . . . . . . . . . . . . . 28
5.1 Algorithme de saisie d’un vecteur . . . . . . . . . . . . . . . . . . . . . . . . 32
5.2 Algorithme d’affichage d’un vecteur . . . . . . . . . . . . . . . . . . . . . . . 33
5.3 Algorithme de recherche séquentielle dans un vecteur . . . . . . . . . . . . . . 34
5.4 Algorithme de recherche dichotomique dans un vecteur . . . . . . . . . . . . . 35
5.5 Algorithme de trie par sélection . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.6 Algorithme de Trie par insertion . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.7 Algorithme de Tri à bulles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.8 Algorithme de saisie d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . 40
5.9 Algorithme d’affichage d’une matrice . . . . . . . . . . . . . . . . . . . . . . 40
7.1 Algorithme de saisie de personnes et de voitures . . . . . . . . . . . . . . . . . 51
7.2 Algorithme de saisie de personnes et de voitures(suite) . . . . . . . . . . . . . 52
8.1 Algorithme affiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.2 Algorithme affiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
8.3 Algorithme de calcul de X y . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
8.4 Algorithme de calcul du PGCD . . . . . . . . . . . . . . . . . . . . . . . . . . 58
v
Chapitre 1
Introduction
Objectifs et plan du chapitre

Objectifs
– Connaître les concepts indispensables pour l’apprentissage de l’algorithmique.
– Connaître l’utilité d’un algorithme dans la phase de production d’un logiciel.
Plan
1. Introduction
2. Notion d’un algorithme
3. Les caractèristiques d’un algorithme
4. De l’algorithme au programme
5. Structure générale d’un algorithme
6. Conclustion
1
CHAPITRE 1. INTRODUCTION
1.1 Notion d’un algorithme

Que ce soit en sciences, en maths ou dans la vie de tous les jours, on devra résoudre de
nombreux problèmes. La résolution d’un problème consiste à définir les différentes étapes à
suivre pour aboutir à une solution. La suite des étapes décrites pour la résolution d’un problème
est appelée « algorithme ».
Un algorithme est donc un ensemble de règles définissant une suite finie d’opérations à
effectuer pour aboutir à la solution d’un problème.
Le passage du problème à l’algorithme nécessite de suivre les étapes suivantes :
1. Délimiter le problème en spécifiant les résultats souhaités.

2. Prendre le soin d’extraire toutes les données essentielles du problème.
3. Réfléchir à une solution au problème en utilisant les données fournies.
4. formaliser la solution obtenue suivant la syntaxe algorithmique.
Définition 1.1
Un algorithme est un ensemble d’instructions écrites suivant une syntaxe bien définie qui une
fois exécutées correctement conduit à un résultat donné. Si l’algorithme est juste, le résultat est
dit correct, sinon, il est dit aléatoire.
On peut modéliser l’algorithme comme étant une entité qui prend en entrée un ensemble de
données et qui, selon les valeurs des données entrées, retourne un ou plusieurs résultats en sortie.
F IGURE 1.1 – modélisation d’un algorithme
1.2 Les caractéristiques d’un algorithme

Validité : La validité d’un algorithme est son aptitude à réaliser exactement la tâche pour la-
quelle il à été conçu.
Robustesse : La robustesse d’un algorithme est son aptitude à se protéger de conditions anor-
males d’utilisation.
Hana JOUINI page 2 Algorithmique Niveau 1

Efficacité : L’efficacité d’un algorithme est son aptitude à utiliser de manière optimale les res-
sources du matériel qui l’exécute.
1.3 De l’algorithme au programme

Dans la plupart des cas, un algorithme ne présente pas une finalité en lui-même. En fait, les
algorithmes sont généralement écrits pour être traduits par la suite en programmes exécutables
sur des machines. Un programme est alors la traduction d’un algorithme en un langage de pro-
grammation reconnu par des machines.
Définition 1.2
Un programme est une suite d’actions que doit effectuer une machine pour obtenir un ensemble
de résultats à partir de données initiales.
Définition 1.3
Un Langage de programmation est un ensemble de vocabulaires et de règles syntaxiques servant
à exprimer des algorithmes.
F IGURE 1.2 – de l’algorithme au programme

1.4 Structure générale d’un algorithme

1.4.1 Les différentes méthodes de représentation d’un algorithme
En informatique, on utilise principalement trois méthodes de représentation du développe-
ment d’un algorithme. Ceci permet de visualiser de manière lisible les différents enchaînements.
1.4.1.1 Le pseudo-langage
Un pseudo langage est un langage constitué de vocabulaires et de règles syntaxiques permet-
tant l’écriture d’un algorithme sous une forme standardisée.
Dans notre cas, on utilise des termes de la langue française permettant d’exprimer d’une
manière directe et souple les actions élémentaires de l’algorithme afin de faciliter l’écriture et
l’apprentissage.
exemple : LIRE (), ECRIRE (), DEBUT, FIN . . ...
1.4.1.2 L’organigramme
Un organigramme est un moyen graphique permettant de visualiser les opérations et les
traitements contenus dans le corps de l’algorithme.
Un organigramme est constitué d’un nombre réduit de symboles simples qui décrivent des
opérations typiques.
exemple :
1.4.1.3 Le Structogramme
Les instructions élémentaires du langage sont schématisées à l’image du fonctionnement du
programme.

d/KEϭ
d/KEϮ
d/KEE
F IGURE 1.3 – structure d’un structogramme
1.4.2 Structure d’un algorithme

La structure générale d’un algorithme est composée de trois parties :
1. EN TÊTE DE L’ALGORITHME
Elle est formée d’un mot clé (Algorithme) suivi du nom de l’algorithme.
2. LES DÉCLARATIONS
Cette partie définie les structures de données sur les quelles travaillera un algorithme. Ces
données sont définies au moyen de trois catégories :
– Les constantes
– Les types
– Les variables
3. CORPS DE L’ALGORITHME
C’est la partie délimitée par les mots clés DEBUT et FIN et contenant les actions à effectuer
par l’algorithme.
La syntaxe générale d’écriture d’un algorithme est alors le suivant :
ALGORITHME <nom_de_algorithme>
VAR
<Déclaration des variables>
DÉBUT
<instructions>
FIN

On peut ajouter deux parties optionnelles qui sont : CONST (déclaration des constantes) et
TYPE (définition de nouvelles types de données).
ALGORITHME <nom_de_algorithme>
CONST
<déclaration des constantes>
TYPE
<définition de nouvelles types de données>
VAR
<Déclaration des variables>
DÉBUT
<instructions>
FIN

Chapitre 2
Les types de données simples et les actions

élémentaires

Objectifs
– Définir les notions de variable et de constante en algorithmique.
– Définir les types de données simples.
– Connaitre la syntaxe d’écritures des instructions élémentaires en algorithmique.
– Écrire son premier algorithme.
– Appliquer les nouvelles connaissances acquises.
Plan
1. Introduction
2. Les variables et les constantes
3. Les types simples
4. Les expressions arithmétiques et logiques
5. Les instruction élémentaires
6. Conclustion
7
CHAPITRE 2. LES TYPES DE DONNÉES SIMPLES ET LES ACTIONS ÉLÉMENTAIRES
2.1 Introduction
Une donnée peut être :
– Une constante : si sa valeur ne change jamais durant les exécutions de l’algorithme.
– Une variable : si sa valeur peut changer durant les exécutions de l’algorithme.
2.2 Les variables et les constantes

Les variables
Une variable peut être considérée comme une boîte portant un identificateur (nom), d’une
certaine forme (type) et qui contient une information (valeur).
Définition 2.1
Une variable est un nom symbolique attaché à un emplacement mémoire.
il est définit par :
nom l’identificateur de la variable. Il doit être unique dans un même algorithme et il est
conseillé qu’il soit significatif de telle sorte qu’il donne une idée sur le contenu de la
variable (prénom, prixUnitaire, moyenne...).
type la nature de la variable. Il détermine les types de données qu’on peut stocker dans la
variable (entier, réel, booléen...).
valeur indique le contenu de lavariable, c’est à dire la valeur stockée dans la variable (5.7, vrai,
faux, ’A’...).
NB : Le nom de la variable doit commencer obligatoirement par une lettre.
Les constantes
Définition 2.2
Les constantes sont des données dont la valeur ne change jamais au cours de l’exécution de
l’algorithme (PI=3.14).
2.3 Les types simples

Ci-dessous un tableau récapitulatif des différents types de données qu’on peut utiliser dans
un algorithme :

Remarques
– Dans l’ensemble des entiers, on distingue :
– La forme d’un réel doit comporter obligatoirement un ’ . ’ et au moins un chiffre avant et

après la virgule.
– Dans l’ensemble des réels on distingue :
– Le type caractère comprend :

– Les 26 lettres latines majuscules (‘A’..’Z’),
– Les 26 lettres latines minuscule (‘a’..’z’),
– Les 10 chiffres (‘0’..’9’),
– Quelques caractères spéciaux (‘return’, ‘ ‘, ‘ !’, ‘"‘,’#’,’$’, ’%’, ‘&’, ‘’’, ‘(‘, ‘)’, ‘*’, ’.’,
‘/’, ‘ :’, ‘ ;’, ‘<’, ‘=’, ‘>’, ‘ ?’ )
– Les caractères sont délimités par deux apostrophes,
– Les carctères sont ordonnées (‘0’< . . .<’9’<’A’<. . .<’Z’<’a’<. . .<’z’<’Return’<. . .<’ ?’).

Les opérations sur les types

Le type Entier :
Le type Réel :
Le type Booléen :
Il y a quatre types d’opérations qu’on peut appliquer sur les Booléens :
ET opération de multiplication logique.
OU opération d’addition logique.
XOR opérateur OU-exclusif.
NEGATION opérateur unaire qui, une fois appliqué sur une variable booléenne, retourne son
opposé (la NEGATION est souvent représentée par le symbole .

Le type Caractère :
2.4 Les expressions arithmétiques et logiques

2.4.1 Les expressions arithmétiques
Définition 2.3
Une expression arithmétique est une suite de valeurs numériques liées par des opérateurs arith-
métiques et dont le résultat est une valeur numérique.
exemple
soient a et b deux entiers, x et y deux réels
x+y*5
6+a*5 DIV 3
(3-y)*b
sont des expressions arithmétiques.
2.4.2 Les expressions logiques

Définition 2.4
Une expression logique est une suite de valeurs liées par des opérateurs arithmétiques ou lo-
giques et dont le résultat est une valeur booléenne.
exemple
soient a et b deux entiers, x et y deux réels
(a<b) ET (x>y)

(a+b<c)OU(a+y>x)
sont des expressions logiques.
2.4.3 Evaluation d’une expression

D’une manière générale, l’évaluation d’une expression se ramène toujours à une succession
d’opérations unaires ( un seul opérande) ou binaires ( deux opérandes). Leur ordre est défini par
les règles de priorité suivantes :
Priorité Opérateurs
1 -, (unaires)
2 Les opérateurs multiplicatifs : * ; / ; DIV ; MOD ; AND
3 Les opérateurs additifs : + ; - ; OR ; XOR
4 Les opérateurs relationnels : = ; <> ; < ; <= ; > ; >=
NB :
les expressions entre parenthèses sont entièrement évaluées avant d’intervenir dans la suite des
calculs. En cas de conflit entre opérateurs de même priorité, l’évaluation se fait de gauche à
droite.
2.5 Les instructions élémentaires

Une instruction est une action effectuée au cours de l’éxecution de l’algorithme. Il y a prin-
cipalement quatre instructions élémentaires :
– L’instruction de déclaration
– L’instruction d’affectation
– L’instruction de lecture
– L’instruction d d’écriture
2.5.1 L’instruction de déclaration

Une instruction de déclaration permet de déclarer toutes les données utilisées dans un algo-
rithme et de préciser leurs types.
syntaxe
<identificateur_variable> : <type_variable> ;
exemple
x1, x2 : entier ;
A,B : réel ;

2.5.2 L’instruction d’affectation

L’affectation sert à donner une valeur à une variable ou à changer sa valeur actuelle.
Dans une instruction d’affectation :
– À gauche du symbole d’affectation ( ), on trouve le nom d’une variable destinée à
recevoir une valeur,
– À droite du symbole d’affectation ( ), on trouve une expression donnant une valeur.
syntaxe
<identificateur_variable> expression ;
exemple
x1 5;
A 2,3 ;
B x1+A ;
La condition la plus importante est que l’expression à évaluer et la variable réceptrice doivent
être de même type ou de types compatibles. Parmi les quatre types standards, seul le type EN-
TIER est compatible avec le type REEL.
exercice1
Donner pour chaque instructions la valeur contenu dans chaque variable :
2.5.3 L’instruction de lecture

En algorithmique, la lecture de la valeur d’une variable se fait à l’aide de la fonction lire().
Cette fonction permet à l’utilisateur de saisir des valeurs à partir du clavier pour qu’elles soient
utilisables par l’algorithme
syntaxe
lire(var1, var2,. . .) ;
exemple
lire(moy) ;
lire(x1, x2, x3) ;

2.5.4 L’instruction d’écriture
En algorithmique, l’écriture de la valeur d’une variable ou d’une expression se fait à l’aide
de la fonction écrire(). Cette fonction permet à l’algorithme de communiquer des valeurs à l’uti-
lisateur en les affichant sur l’écran.
syntaxe
écrire(exp1, exp2,. . .) ;
exemple
écrire(’A’) ;
écrire(x1, x2, x3) ;
exercice 1 Ecrire un algorithme qui lit trois entiers, calcule leur moyenne et l’affiche.
Algorithme 2.1 Algorithme moyenne

algorithme moyenne
var
somme, note1, note2, note3 : entier ;
moyenne : réel ;
Début
écrire(“donner trois notes : “) ;
lire(note1) ;
lire(note2) ;
lire(note3) ;
somme note1+note2+note3 ;
moyenne somme/3 ;
écrire(“la somme est :”, somme) ;
écrire(“la moyenne est :”, moyenne) ;
Fin
exercice 2
Ecrire un algorithme qui lit :
– Le montant lors taxe d’un article,
– Le taux de tva,
– Le nombre d’articles,
Et qui affiche le total tout taxes compris.
Note : Total_TTC = nbrArticle * mont_HT*(1 + taux_Tva)
2.6 Conclusion
Un algorithme est une suite d’instructions élémentaires telle que l’affectation, la lecture,
l’écriture...etc

Chapitre 3
Les structures conditionnelles

Objectifs
– Connaitre les limites des traitements séquentiels.
– Définir les structures :
– conditionnelle simple
– conditionnelle généralisée
– conditionnelle imbriquée
– la structure selon
Plan
1. Introduction
2. La struture si..alors
(a) Le conditionnelle simple
(b) Le conditionnelle généralisée
(c) Le conditionnelle imbriquée
3. La structure selon
4. Conclustion
16
CHAPITRE 3. LES STRUCTURES CONDITIONNELLES
3.1 Introduction
Dans un algorithme, les instructions s’exécutent séquentiellement les unes après les autres,
dans l’ordre où elle apparaissent. Or dans la vie réelle, pour résoudre un problème, on peut se
trouver dans un cas ou on doit choisir d’éffectuer un traitement ou un autre.
Un algorithme doit donc donner la possibilité d’effectuer des choix, autrement dit d’avoir
des comportements qui puissent dépendre des résultats intermédiaires. On parle dans ce cas de
structure de conditionnelles.
3.2 la structure si. . .alors

3.2.1 Le conditionnel simple
On peut demander à un algorithme de n’exécuter des instructions que si une certaine condi-
tion est remplie.
F IGURE 3.1 – modélisation de la structure conditionnelle simple
syntaxe
SI <condition> ALORS
<traitement>
FSI
NB <condition> est une expression logique dont le résultat est un booléen.
exercice 3 Ecrire un algorithme qui affiche la valeur absolue de la différence entre 2 nombres
saisis au clavier.

Algorithme 3.1 Algorithme valeur absolue

ALGORITHME ValAbsolue
VAR
A, B, C : Réel ;
DEBUT
Lire(A)
Lire(B)
C A-B
Si (C<0) Alors
C -C
FSi
Ecrire (‘’la valeur absolue de la différence est : ’’, C)
FIN
3.2.2 Le conditionnel généralisé

Dans ce cas on ajoute un traitement à exécuter si la condition n’est pas vérifiée.
F IGURE 3.2 – modélisation de la structure conditionnelle généralisée
syntaxe
SI <condition> ALORS
<traitement1>
SINON
<traitement2>
FSI

exercice 4 écrire un algorithme qui vérifi si une note est comprise entre 0 et 20.
Algorithme 3.2 Algorithme note

ALGORITHME note
VAR
n : ENTIER
DEBUT
ECRIRE ("Entrer une note")
LIRE ( n)
Si (n<0) ou ( n> 20) Alors
ECRIRE ( " note erronée")
Sinon
ECRIRE ( " note correct")
Fsi
Fin
3.2.3 Le conditionnel imbriqué

C’est un mélange des deux structures ’conditionnel simple’ et conditionnel généralisé’.
syntaxe
SI <condition1> ALORS
<traitement1>
SINON SI <condition2> ALORS
<traitement2>
FSI
SINON
<traitement3>
FSI
exemple Un rebot conduit une voiture il peut exécuter 3 actions « s’arrêter », « ralentir », «
passer » en fonction de la couleur des feux qui sera une variable saisie. Supposons que la couleur
des feux qui sera une variable saisie. Supposons que la couleur des feux est représenté par une
variable de type caractère qui reçoit l’un des 3 valeurs ‘R’, ‘V’ ou ‘O’.

Algorithme 3.3 Algorithme Robot

AGOTIYHME RoboFeux
VAR Couleur : caractère ;
DEBUT
Lire (couleur) ;
Si (couleur = ‘R’) Alors
Ecrire(‘’je m’arrête ‘’) ;
Sinon Si (couleur = ‘O’) Alors
Ecrire (‘’je ralentis’’) ;
Sinon
Ecrire(‘’Je passe’’) ;
FSi
FSi
FIN
3.3 La structure selon

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.
syntaxe
SELON <expression> FAIRE
<Valeur 1> : traitement 1 ;
<valeur 2> : traitement 2 ;
<valeur 3> : traitement 3 ;
...
[SINON <traitement par défaut>]
FINSELON
La variable ( ou l’évaluation de l’expression) est comparée aux différentes constantes (va-
leur1, valeur2, . . .,valeurn) et les actions exécutées dépendent de cette valeur ( par exemple, si
la variable est égale à valeur 1 alors action 1 est exécutée) Dans le cas ou la variable n’est égale
à aucune des constantes énumérées, c’est l’action relative à la partie « SELON » qui sera alors
exécutée.
exemple
SELON nombre FAIRE
0 : Ecrire(‘’nombre nul et paire’’) ;
1,3,5,9 : Ecrire(‘’nombre impaire’’) ;
2,4,6 : Ecrire(“Nombre paire’’) ;
10..14 : Ecrire(“nombre très grand “) ;
FinSelon

3.4 Conclusion
Les structures conditionnelles permettent d’enrichir le traitement séquentielle d’un algo-
rithme en donnant la possibilité d’exécuter un ensemble d’instructions relatif à une certaine
condition.

Chapitre 4
Les structures itératives

Objectifs
– Définir la notion d’une structure répétitive.
– Définir :
– La boucle Pour
– La boucle Tant que
– La boucle Répéter
Plan
1. Introduction
2. La boucle Pour
3. La boucle Tant que
4. La boucle Répéter
5. Conclustion
22
CHAPITRE 4. LES STRUCTURES ITÉRATIVES
4.1 Introduction
Supposons qu’on veuille afficher les 10 premiers entiers positifs. Si on utilise le traitement
séquentie on aura l’algorithme suivant :
ALGORITHME affiche
VAR
DébUT
Ecrire(0) ;
Ecrire(1) ;
Ecrire(2) ;
...
Ecrire(9) ;
FIN
Cette méthode reste raisonnable pour un petit nombre mais si on veut afficher les n premiers
entiers avec n = 1000, l’algorithme devient alors absurde et impossible à écrire. Pour pouvoir
écrire un tel algorithme, on aura besoin d’une structure qui permet de répéter auotomatiquement
une instruction ou un groupe d’instructions. On doit alors utiliser des structures répétitives.
Une structure répétitive est une structure qui répète un même traitement autant de fois que
l’on veut pour vue que la condition d’exécution soit satisfaite. Cette boucle s’arrête lorsque cette
condition n’est plus vérifiée. Il existe trois schémas (boucles) de représentation d’une structure
répétitive à savoir :
– la boucle Pour
– la boucle Tant que
– la boucle Répéter
4.2 La boucle Pour

La boucle Pour est une structure répétitive qui itère le même traitement pour une plage
de valeurs entières comprises entre une borne inférieure et une borne supérieure. L’arrêt du
traitement de la boucle Pour se réalise lorsqu’on dépasse l’une des bornes.

F IGURE 4.1 – Modélisation de la boucle Pour
syntaxe
POUR <compteur> DE <borne_inférieure> À <borne_supérieure> PAS <incrément> FAIRE
<traitement>
FPOUR
avec
<compteur> variable de type entier.
<borne_inférieure> valeur de type entier.
<borne_supérieure> valeur de type entier.
<incrément> valeur de type entier.
NB : ne modifier jamais la valeur du compteur dans une insruction Pour.
si on ne spécifie pas la valeur du PAS dans l’instruction POUR il prends par défaut la valeur :
– 1 si <borne_inférieure> < <borne_supérieure>
– -1 si <borne_inférieure> > <borne_supérieure>
exemeple affichage des N premiers entiers.

Algorithme 4.1 Algorithme affichage des N premiers entiers (boucle Pour)

ALGORITHME afficher
VAR
i : entier
N : entier
DÉBUT
Lire (N)
Pour i DE 0 À N FAIRE
Ecrire(i) ;
FPOUR
FIN
4.3 La boucle Tant que

La boucle TANT QUE exécute un traitement tant qu’une condition est VRAIE.
syntaxe
TANT QUE <condition> FAIRE
< Actions>
FTANTQUE
F IGURE 4.2 – Modélisation de la boucle Tant que

exemple affichage des N premiers entiers.
Algorithme 4.2 Algorithme affichage des N premiers entiers (boucle Tant que)
ALGORITHME afficher
VAR
i : entier
N : entier
DÉBUT
Lire (N)
i 0;
TANT QUE i <=N FAIRE
Ecrire(i) ;
i i+1 ;
FTANTQUE
FIN
4.4 La boucle Répéter

La boucle Répéter permet de rentrer dans la boucle quelque soit la condition et réitère l’exé-
cution jusqu’à ce que la condition soit vérifiée.
NB :
– Dans une boucle Répéter, le traitement est exécuté au moins une fois quelle que soit la
valeur de la condition d’arrêt.
– Dans une boucle Répéter, on parle de condition d’arrêt. Quant la condition d’arrêt est
atteinte (<condition> prend la valeur vrai), on sort de cette boucle.
F IGURE 4.3 – Modélisation de la boucle Répeter

syntaxe
Répéter
<traitement>
jqà (<condition>)
exemple affichage des N premiers entiers.
Algorithme 4.3 Algorithme affichage des N premiers entiers (boucle Répéter)

ALGORITHME afficher
VAR
i : entier
N : entier
DÉBUT
Lire (N)
i 0;
Répéter
Ecrire(i) ;
i i+1 ;
jqà (i>N)
FIN
exercice 5 Ecrire un algorithme qui calcule la moyenne de N notes saisies en entrée. Utiliser
les 3 shémas itératifs.
– Solution à l’aide de la boucle Pour
Algorithme 4.4 Algorithme moyenne avec la boucle Pour

ALGORITHME moyenneN
VAR
N, i, S, M : entier ;
DÉBUT
S 0;
lire(N) ;
pour i de 1 à N faire
S S+i ;
fpour
M S/N ;
écrire(“la moyenne est :”,M) ;
FIN
– Solution à l’aide de la boucle Tant que

Algorithme 4.5 Algorithme moyenne avec la boucle Tant que

ALGORITHME moyenneN
VAR
DÉBUT
S 0;
i 1;
lire(N) ;
tant que i<=N faire
S S+i ;
i i+1 ;
fTantque
M S/N ;
FIN
– Solution à l’aide de la boucle Répéter
Algorithme 4.6 Algorithme moyenne avec la boucle Répéter

ALGORITHME moyenneN
VAR
DÉBUT
S 0;
i 1;
lire(N) ;
Répéter
S S+i ;
i i+1 ;
jqà (i>N)
M S/N ;
FIN
4.5 Conclusion
On ne peut utiliser la boucle Pour que si on connait à prioris le nombre d’itérations contraire-
ment aux boucles Tant que et Répéter qui peuvent être utilisées même si on connait pas combien
d’itérations seront nécessaires pour obtenir le résultat.

la boucle " REPETER" est utilisée s’il est nécessaire d’exécuter au moins une fois le bloc
d’instructions.

Chapitre 5
Les tableaux

Objectifs
– Comprendre l’intérêt de l’application d’un type composé
– Définir les structures :
– vecteur
– matrice
Plan
1. Introduction
2. Les vecteurs
(a) Déclaration d’un tableau de type vecteur
(b) L’accès à un élément d’un vecteur
(c) La saisie et l’affichage d’un vecteur
(d) La recherche d’un élément dans un vecteur
– Recherche séquentielle
– Recherche dichotomique
3. Les matrices
(a) Déclaration d’une matrice
(b) L’accès à un élément d’une matrice
(c) La saisie et l’affichage d’une matrice
4. Conclustion
30
CHAPITRE 5. LES TABLEAUX
5.1 Introduction
Le tableau est une struture de données (un type) utilisée pour représenter un ensemble d’élé-
ments ayant tous le même type et dont le nombre d’éléments est connu à priori. Le type des
éléments est le type de base. il peut être simple ou complexe.
on distingue deux types de tableaux selon la nature des éléments :
– Les tableaux unidimensionnels ou vecteurs : ce sont des tableaux dont le type de base est
simple.
– Les tableaux multidimensionnels : ce sont des tableaux dont le type de base est un tableau.
Le type de base qui est un tableau peut lui même avoir des éléments de type Tableau ! On
aura donc un tableau à plusieur dimensions. Dans ce cours, on va étudier les tableaux à
deux dimensions ou matrices.
5.2 Les vecteurs

5.2.1 Déclaration d’un tableau de type Vecteur
La déclaration du tableau se fait, comme toute variable, dans la partie VAR de l’algorithme.
Il est conseillé de créer un nouveau type pour les tableaux avant de déclarer des variables. La
syntaxe de déclaration d’un vecteur est le suivant.
syntaxe
TYPE
Nomtype = Tableau[<borne_inf> .. <borne_sup>] de <type_élément> ;
VAR
NomTableau : Nomtype ;
exemple
TYPE
Tab_Moy = Tableau[1..4] de réel ;
VAR
T : Tab_Moy ;
T peut être de la forme :
Chaque élément du tableau possède un indice avec lequel on peut accèder à l’élément. Par
exemple la case qui contient la valeur 5.0 est accessible grâce à son indice 3.

5.2.2 L’accès à un élément du vecteur

Pour accèder à un élément du tableau, il suffit de spécifier son indice.
syntaxe
<NomTableau>[<indice>]
exemple
T[1]
T[4]
Ici, la valeur de T[1] est égale à 2.3 et la valeur de T[4] est 10.1
NB : Dans ce qui suit, on va utiliser l’exemple d’un tableau T d’entiers.
5.2.3 Le saisie et l’affichage d’un vecteur
Algorithme 5.1 Algorithme de saisie d’un vecteur

ALGORITHME saisie_tableau
CONST
N : max ;
TYPE
TabEnt : Tableau [1..N] de Entier ;
VAR
T : TabEnt ;
I : entier ;
DÉBUT
Pour I de 1 à N faire
lire (T(I) ) ;
FPour
FIN

Algorithme 5.2 Algorithme d’affichage d’un vecteur

CONST
N : max ;
TYPE
TabEnt = Tableau [1..N] de Entier ;
VAR
T : TabEnt ;
I : entier ;
DÉBUT
Pour I de 1 à N faire
écrire (T(I) ) ;
FPour
FIN
5.2.4 La recherche d’un élément dans un vecteur

Il s’agit de chercher un élément, saisi à partir du clavier, dans un tableau. Dès qu’on le trouve
ce n’est plus la peine de continuer le parcours du tableau, on doit sortir et afficher un message
d’existence. Il y a plusieurs façons de faire. Dans ce cours, on va étudier seulement deux :
– La recherche séquentielle : On parcours le tableau élément par élément et au moment ou
on trouve l’élément cherché on arrête le parcours et affiche l’élément.
– La recherche dichotomique : c’est une recherche plus optimisée qui minimise le temps
d’exécution de l’algorithme.

5.2.4.1 La recherche séquentielle
Algorithme 5.3 Algorithme de recherche séquentielle dans un vecteur

ALGORITHME Rech_Seq
CONST
N = 20 ;
TYPE
TabEnt = Tableau [1..N] de Entier ;
VAR
T : TabEnt ;
I : entier ;
X : entier ; (* X est l’élément à chercher dans le tableau *)
Trouve : Booléen (* cette variable va nous permettre de sortir dès qu’on trouve X *)
DÉBUT
Lire(X) ;
I 1;
Trouve Faux ;
Tant que (I<=N) et (Trouve = Faux) Faire
Si (T(I) <> X) Alors
I I + 1;
Sinon
Trouve Vrai ;
FinSi
Fintq
Si (Trouve = Vrai) Alors
Écrire(X, ‘appartient à T’) ;
Sinon
Écrire (X,’ne se trouve pas dans T’) ;
FinSi
FIN
5.2.4.2 La recherche dichotomique

Pour pouvoir appliquer la recherche dichotomique, il faut que le tableau T soit Trié. Il s’agit
d’une recherche qui permet de réduire le temps de recherche d’un élément X dans un tableau T.

Algorithme 5.4 Algorithme de recherche dichotomique dans un vecteur

ALGORITHME Dichoto
CONST
N : max ;
TYPE
TabEnt : Tableau [1..N] de Entier ;
VAR
T : TabEnt ;
I,inf,sup,mil : entier ;
X : entier ; (* X est l’élément à chercher dans le tableau *)
DÉBUT
Lire(X)
inf 1;
sup N;
Répéter
mil (inf+sup) div 2 ;
Si (X < T(mil)) Alors
sup mil – 1 ;
Sinon
inf mil +1 ;
FinSi
Jqà (X=T(mil)) ou (inf > sup)
FIN
5.2.5 Le trie d’un vecteur

Il existe plusieurs algorithmes permettant d’ordonner les éléments d’un tableau. On cite :
– Le tri par sélection
– Le Tri par insertion
– Le Tri à bulles

Le trie par sélection
Algorithme 5.5 Algorithme de trie par sélection

ALGORITHME Tri_Sélection
CONST
n : entier
TYPE
Tab_Entier = Tableau[1..n] de Entier ;
VAR
Min, ind, temp, i : entier ;
T : Tab_Entier ;
DÉBUT
Pour i de 1 à (n-1) Faire
min ind ;
Pour i de (ind+1) à n Faire
Si (T(i) < T(min)) Alors
min i;
FinSi
FPour
Temp T(ind) ;
T(ind) T(min) ;
T(min) := temp ;
FPour
Fin

Le trie par insertion
Algorithme 5.6 Algorithme de Trie par insertion

ALGORITHME Tri_Insertion
CONST
n : entier
TYPE
Tab_Entier = Tableau[1..n] de Entier
VAR
i, j, aux : entier ;
T : Tab_Entier ;
DÉBUT
Pour i de 2 à n Faire
aux T(i) ;
j (i-1) ;
Tant que ( j > 0 ) et ( T(j) > aux ) Faire
T(j+1) T(j) ;
J j-1 ;
FTantque
T(j+1) aux ;
Fpour
FIN

Le Tri à bulles
Algorithme 5.7 Algorithme de Tri à bulles

ALGORITHME Tri_Bulles
CONST
n : entier ;
TYPE
Tab_Entier = Tableau[1..n] de Entier ;
VAR
Permute : Booléen ;
i, temp : entier ;
T : Tab_Entier ;
DÉBUT
Répéter
permute faux ;
Pour i de 2 à n Faire
Si (T(I-1) > T(i)) Alors
Permute vrai ;
Temp T(i-1) ;
T(i-1) T(i) ;
T(i) temp ;
FinSi
FinPour
Jqà (Non(permute))
FIN
5.3 Les matrices

Un tableau à deux dimensions appelé également matrice est un vecteur dont le type de base
est Tableau. Il permet donc d’organiser des informations de même type en lignes et en colonnes.
exemple
Chaque élément de la matrice est repéré par deux indices : son indice de ligne et son indice de
colonne. Par exemple, la case dont la valeur est 5 est repérée par l’indice de ligne 2 et l’indice de

colonne 1. Ainsi, chaque case est identifiée uniquement à l’aide du couple (i, j) avec i représente
le numéro de ligne et j représente le numéro de colonne.
5.3.1 Déclaration d’une matrice

La syntaxe de déclaration d’une matrice est la suivante :
syntaxe
TYPE
Matrice = Tableau [1..<Nbr_Lig>, 1..<Nbr_Col>] de <Type_Élément_Matrice> ;
VAR
M : Matrice ;
exemple la déclaration de la matrice de l’exemple précédent est la suivante :

exemple
TYPE
Matrice = Tableau[1..4, 1..3] de Entier ;
VAR
mat : Matrice ;
5.3.2 L’accès à un élément d’une matrice

Pour accèder à un élément d’une mmatrice, il suffit de spécifier ses indices de ligne et de
colonne.
syntaxe
<NomMatrice>[i, j]
exemple
mat[1, 3]
mat[4, 2]
Ici, la valeur de mat[1, 3] est égale à 8 et la valeur de mat[4, 2] est 1.

5.3.3 Le saisie et l’affichage d’une matrice
Algorithme 5.8 Algorithme de saisie d’une matrice

CONST
Nbr_Lig : N1 ;
Nbr_Col : N2 ;
TYPE
Matrice : Tableau[1..4, 1..3] de Entier ;
VAR
mat : Matrice ;
I,J : entier ;
DÉBUT
Pour I de 1 à Nbr_Lig Faire
Pour J de 1 à Nbr_Col Faire
Lire(M[I,J])
FPour
FPour
FIN
Algorithme 5.9 Algorithme d’affichage d’une matrice

CONST
Nbr_Lig : N1 ;
Nbr_Col : N2 ;
TYPE
Matrice : Tableau[1..4, 1..3] de Entier ;
VAR
mat : Matrice ;
I,J : entier ;
DÉBUT
Pour I de 1 à Nbr_Lig Faire
Pour J de 1 à Nbr_Col Faire
écrire(M[I,J])
FPour
FPour
FIN
exercice 6 écrire un algorithme qui lit une valeur entière X saisie au clavier et cherche si elle
existe dans une matrice d’entiers de taille N*M.

5.4 Conclusion
Un tableau est une structure de données qui permet de repérer simultanément un ensemble
de valeurs de même types. Il existe plusieurs types de tableaux et le choix se fait selon le la
nature du problème à résoudre.

Chapitre 6
Les chaînes de caractères

Objectifs
– Découvrir le type chaîne de caractère.
– Connaître les fonctions prédéfinies sur les chaînes de caractères.
Plan
1. Introduction
2. Opérations sur les chaines de caractères
(a) La lecture et l’affichage d’une chaine
(b) Les fonctions prédéfinies sur les chaines
3. Conclustion
42
CHAPITRE 6. LES CHAÎNES DE CARACTÈRES
6.1 Introduction
Une chaîne de caractères est une suite finie de caractères. On peut utiliser la structure de
données Tableau (qui aura comme type de base le type caractère) pour modéliser une chaîne de
caractères. On peut alors définir une chaîne de caractères comme suit :
syntaxe
TYPE
Chaine : Tableau[<Taille_Maxi>] de caractère ;
VAR
<Nom_Variable> : Nom_Chaine ;
exemple TYPE
Chaine : Tableau[30] de caractère ;
VAR
prénom : Chaine ;
6.2 Opérations sur les chaînes de caractères

6.2.1 La lecture et L’affichage d’une chaîne
– La lecture
Comme toute autre variable en algorithmique, la lecture se fait à l’aide la fonction lire.
exemple lire(ch1), lire(ch1, ch2, ch3)
– L’affichage
De même, pour afficher une chaîne sur l’écran on utilise la fonction écrire.
exemple écrire(ch1), écrire(ch1, ch2, ch3)
6.2.2 Les fonctions prédéfinies sur les chaînes

Pour faciliter la manipulation des chaînes, on va définir un ensemble de fonctions dites pré-
définies qui permettent réaliser certains traitements courament appliqués sur les chaînes.
Opération données en entrée résultat

init_chaine ø chaîne
ajout_car chaîne+caractère chaîne
supp_car chaîne+entier chaîne
pos_car chaîne+caractère entier
longueur chaîne entier
chaine_vide chaîne booléen
chaine_pleine chaîne booléen

Soit ch une variable de type chaîne de caractères et c un caractère quelconque.

ch = “bonjour tunisie”
La fonction init_chaine
Elle retourne une chaine dont la taille est zéro.
syntaxe
init_chaine()
exemple
ch1 init_chaine() ;
La fonction ajout_car
La condition pour appliquer cette fonction est que la chaine ne soit pas pleine. Le nouveau
caractère est ajouté en fin de la chaine et le résultat est une nouvelle chaine de taille augmentée
de 1.
syntaxe
ajout_car(<chaine>, <caractère>) ;
exemple
ajout_car(ch, ’.’) ;
Dans cette exemple, on veut ajouter le caractère ’.’ en fin de la chaîne, on aura ch = “bonjour
tunisie.”
La fonction supp_car
La condition pour appliquer cette fonction est que la chaine ne soit pas vide. Le caractère qui
sera supprimé est celui dont la position est passée en paramétre et le résultat est une nouvelle
chaine de taille diminuée de 1.
syntaxe
supp_car(<chaine>, <entier>) ;
exemple
supp_car(ch, 1) ;
on aura ch = “onjour tunisie”
La fonction pos_car
Cette fonction retourne la position de la première occurrence du caractère passé en paramètre
syntaxe
pos_car(<chaine>, <caractère>) ;
exemple
p pos_car(ch, ’o’) ;
On aura p = 2

La fonction longueur
Cette fonction retourne la longueur d’une chaîne, soit le nombre de caractères qui la forment.
syntaxe
longueur(<chaine>) ;
exemple
n longueur(ch) ;
On aura n = 15
La fonction longueur
Cette fonction retourne la longueur d’une chaîne, soit le nombre de caractères qui la forment.
syntaxe
longueur(<chaine>) ;
exemple
n longueur(ch) ;
On aura n = 15
La fonction chaine_vide
Cette fonction retourne vrai si la chaine a une longueur nulle sinon elle retourne faux.
syntaxe
chaine_vide(<chaine>) ;
exemple
b chaine_vide(ch) ;
On aura b = faux
La fonction chaine_pleine
Cette fonction retourne vrai si la chaine a atteint sa longueur maximale sinon elle retourne
faux.
syntaxe
chaine_pleine(<chaine>) ;
exemple
b chaine_pleine(ch) ;
exercice 7
Écrire un algorithme qui calcule et affiche la longueur de la plus longue suite croissante
d’une chaîne données de taille maximale max.

6.3 Conclusion
Le type chaîne de caractere permet le regroupement et la manipulation d’une suite de valeurs
aphanumériques(lettres, de signes de ponctuation, d’espaces ou des chiffres). On peut représen-
ter une chaîne à l’aide d’un vecteur dont le type de base est le caractère.

Chapitre 7
Les enregistrements

Objectifs
– Définir la structure de données enregistrement
– Se familiariser à l’utilisation des enregistrements.
Plan
1. Introduction
2. Déclaration et accès à une variable de type enregistrement.
3. Conclustion
47
CHAPITRE 7. LES ENREGISTREMENTS
7.1 Introduction
L’enregistrement est une structure de données qui permet de représenter un ensemble d’in-
formations qui n’ont pas forcément toutes le même type. Les informations contenues dans un
enregistrement s’appellent les composantes de l’enregistrement. Le nombre et les types des com-
posants d’un enregistrement devraient être fixés au départ.
7.2 Déclaration d’une variable de type enregistrement

syntaxe
<nom_enregistrement> = enreg
<C1> : <type1>
<C2> : <type2>
<C3> : <type3>
.
.
.
<CN> : <typeN>
fenreg
exemple
etudiant = enreg
num : entier
nom : chaine de caractères
jour : entier
mois : entier
ans entier
fenreg
on peut écrire l’enregistrement etudiant d’une autre façon en définissant un nouveau enre-
gistrement date :
date = enreg
jour : entier
mois : entier
ans entier
fenreg
on aura donc :
etudiant = enreg
num : entier
date_naissance : date

fenreg
L’accès à une composante de l’enregistrement

Pour accéder aux composants d’un enregistrement, on doit effectuer tout d’abord une opéra-
tion lecture, écriture, affectation, etc. en outre, cet accès peut être total ou partiel :
– Dans le cas où l’accès est total, on utilise <Nom_enregistrement>.
– Dans le cas où l’accès se fait à une composante, on utilise <Nom_enregistrement>.<nom_composante>
exemple
Soit e une variable de type etudiant. Pour accèder au nom de l’ étudiant on tape e.nom
Pour accèder à l’année de sa naissance on tape e.date.an
7.3 Application
Soit un ensemble de personnes (max = 1000 personnes) et un ensemble de voitures (max =
5000 voitures). Chaque personne est caractérisée par son numéro(entier) et son nom. Une voiture
est caractérisée par son numéro de matriculation, sa marque et sa date de fabrication sous forme
de jour, mois et année.
Chaque personne possède au maximum 5 voitures.
1. Définir la structure de données adéquate pour représenter une voiture.
2. Définir la structure de données pour la représentation d’une personne.
3. Quelle structure de données peut on utiliser pour représenter un ensemble de n personnes
et un ensemble de m voitures ? Définir ces structures.
4. Écrire un algorithme qui saisit m voitures et n personnes. On suppose que les personnes
ne possèdent pas de voitures lors de la saisie.
Solution
1. date = enreg
jour : entier
mois : entier
ans entier
fenreg
voiture = enreg
immat : chaine de caractères
marque : chaine de caractères
date_fabrication : date

fenreg
2. personne = enreg
num : entier
nbe_voitures : entier
tab_voitures : tableau[1..5] de voiture
fenreg
3. Pour définir un ensemble de variables tous de même type, on utilise la structure tableau. On
peut définir les types suivants :
tab_personnes : tableau[1..1000] de personne
4.

Algorithme 7.1 Algorithme de saisie de personnes et de voitures

ALGORITHME personne_voiture
TYPE
date = enreg
jour : entier
mois : entier
ans entier
fenreg
voiture = enreg
immat : chaine de caractères
marque : chaine de caractères
date_fabrication : date
fenreg
personne = enreg
num : entier
nbe_voitures : entier
fenreg
tab_personnes : tableau[1..1000] de personne
VAR
p : personne ;
v : voiture ;
t_pers : tab_personnes ;
t_voit : tab_voitures ;
i, p, n : entier ;
DÉBUT
répéter
écrire(“donner le nombre de voitures :”) ;
lire(n) ;
jqà(n>=1 et n<=5000)
répéter
écrire(“donner le nombre de personnes :”) ;
lire(p) ;
jqà(p>=1 et p<=1000)

Algorithme 7.2 Algorithme de saisie de personnes et de voitures(suite)

pour i de 1 à n faire
écrire(“donner le numéro d’immatriculation de la voiture ”, i) ;
lire (v.immat) ;
écrire(“donner la marque de la voiture ”, i) ;
lire(v.marque) ;
écrire(“donner la date de fabrication de la voiture ”, i) ;
lire(v.date_fabrication.jour) ;
lire(v.date_fabrication.mois) ;
lire(v.date_fabrication.an) ;
t_voit[i] v;
fpour
pour i de 1 à p faire
écrire(“donner le numéro de la personne ”, i) ;
lire (p.num) ;
écrire(“donner le nom de la personne ”, i) ;
lire(p.nom) ;
p.nbe_voitures 0;
t_pers[i] p;
fpour
FIN
7.4 Conclusion
Contrairement aux tableaux qui sont des structures de données dont tous les éléments sont
de même type, les enregistrements sont des structures de données dont les éléments peuvent être
de type différent et qui se rapportent à la même entité.

Chapitre 8
Les procédures et les fonctions

Objectifs
– Introduire la méthode de l’analyse ascendante.
– Définir la structure d’une procédure.
– Définir la structure d’une fonction.
– Extraire les différences entre la structure procédure et la structure fonction.
– Définir la notion de récursivité.
Plan
1. Introduction
2. Analyse et décomposition des problèmes
3. Les procédures
(a) Structure d’une procédure
(b) Utilisation d’une procédure
4. Les fonctions
(a) Structure d’une fonction
(b) Utilisation d’une fonction
5. La Portée des Variables
6. Comparaison entre les procédures et les fonctions
7. Conclustion
53
CHAPITRE 8. LES PROCÉDURES ET LES FONCTIONS
8.1 Introduction
Les problèmes jusque là traités peuvent être classés dans la catégorie des problèmes faciles ;
c’est à dire que leur résolution se ramène à une suite finie d’actions simples, qui, si elles sont
correctement exécutées, fourniront le(s) résultat(s) souhaité(s). En réalité, les problèmes rencon-
trés sont plus complexes et leur solution n’est pas immédiate : pour obtenir le résultat final, on
doit passer par des résultats intermédiaires solutions de sous problèmes inclus dans le problème
principal. C’est pour cette raison , que pour résoudre un problème, on doit le décomposer en
sous problèmes. Si la complexité persiste, on continuera la décomposition jusqu’à arriver à un
niveau de décomposition où tous les sous problèmes trouvés seront faciles à résoudre.
8.2 Analyse et décomposition des problèmes

Il s’agit de décomposer le problème initial en sous problèmes de complexité inférieure. La
méthode utilisé est dite la méthode de l’analyse descendante.
F IGURE 8.1 – Analyse descendante
La complexité d’un problème donné conduit à le diviser en plusieurs sous problèmes de

difficulté moindre jusqu’à ce que l’on arrive à des éléments proches des structures élémentaires
du langage utilisé. L’avantage de ce type d’analyse est qu’il permet d’appréhender un problème
avec une vision globale avant d’entrer trop tôt dans des considérations de détails.
Ainsi, pour chaque sous problème on va lui associer son sous-algorithme, lui même on lui
fait correspondre des sous-algorithmes.
On distingue alors deux catégories de sous-algorithmes : Les fonctions et les procédures.
8.3 Les procédures

Une procédure est un sous-algorithme qui prend en entrée zéro ou plusieurs paramètres,
exécute une suite d’instructions pour réaliser une tâche.

8.3.1 Structure d’une procédure

PROCEDURE <nom_procédure> (param1 :type1,param2 :type2,. . .,paramN :TypeN)
VAR
<déclaration des variables>
DÉBUT
<traitement>
FIN
NB : param1, param2, . . ., paramN sont appelés paramètres : ce sont des variables qui per-
mettent à la procédure de communiquer avec l’extérieur. Ces paramètres déclarés lors de
la définition de la procédure sont appelés paramètres formels. On peut trouver certaines
procédures sans paramètres ; on déclarera alors la fonction de la manière suivante : Procé-
dure nomproc().
exemple
PROCÉDURE aff_somme(a :entier, b :entier)
VAR
S : entier
DÉBUT
S := a + b
écrire(S)
FIN
8.3.2 Utilisation d’une procédure

L’utilisation (ou l’appel) d’une procédure revient en fait à l’écriture d’une instruction dans
un algorithme.
syntaxe
<Nomproc>(var1, var2, . . .., varN)
var1, var2, . . .., varN sont des paramètres dites effectifs.
Algorithme 8.1 Algorithme affiche

ALGORITHME affiche
VAR
x,y : entier
DÉBUT
Écrire(‘donnez un entier x : ‘)
Lire(x)
Écrire(‘donnez un entier y : ‘)
Lire(y)
aff_somme(x,y)
FIN

8.4 Les fonctions

Une fonction est un sous-algorithme qui prend en entrée zéro ou plusieurs paramètres, exé-
cute une suite d’instructions pour réaliser une tâche et retourne le résultat au algorithme appelant.
8.4.1 Structure d’une fonction

FONCTION <nom_fonction> (param1 :type1,param2 :type2,. . .,paramN :TypeN) :<type_de_retour>
VAR
<déclaration des variables>
DÉBUT
<traitement>
retourner(<valeur_de_retour>) ;
FIN
NB : une fonction retourne un résultat unique. On peut trouver certaines fonctions sans pa-
ramètres, on déclarera alors la fonction de la manière suivante : Fonction nomfonct() :
typefonction.
exemple
FONCTION calcul_somme(a :entier, b :entier) :entier
VAR
S : entier
DÉBUT
S := a + b
retourner(S) ;
FIN
8.4.2 Utilisation d’une fonction

L’utilisation (ou l’appel) d’une fonction revient en fait à l’écriture d’une instruction(en gé-
néral d’affectation) dans un algorithme.
syntaxe
<nom_var> <Nomfonc>(var1, var2, . . .., varN)
NB : <nom_var> doit avoir le même type que le type de retour de la fonction.

Algorithme 8.2 Algorithme affiche

ALGORITHME affiche
VAR
x,y,Somme : entier ;
DÉBUT
Écrire(‘donnez un entier x : ‘) ;
Lire(x) ;
Écrire(‘donnez un entier y : ‘) ;
Lire(y) ;
Somme aff_somme(x,y) ;
écrire(Somme) ;
FIN
8.5 La Portée des Variables

La portée d’une variable est l’étendue de l’algorithme dans laquelle la variable est reconnue
et peut être par conséquent utilisée. Une variable peut être définie de deux façons :
– Variable Locale Une variable locale a une portée qui se limite dans l’algorithme ou le
sous-algorithme dans lequel est définie. Elle ne peut être ni vue, ni utilisée, par les autres
sous-algorithmes.
– Variable Globale Une variable globale a une portée qui s’étend sur la structure générale de
l’algorithme. Elle est reconnue dans tout l’algorithme Une variable globale est précédée
par le terme Globale lors de sa déclaration.
8.6 Comparaison entre les procédures et les fonctions

– Les paramètres d’Entrée : Les paramètres d’une procédure peuvent être de type Entrée,
Sortie, Entrée/ Sortie c’est-à-dire transmis par valeur ou par adresse alors que les para-
mètres d’une fonction sont des paramètres transmis uniquement par valeur donc modi-
fiable.
– Les paramètres de Sortie : La procédure peut fournir plusieurs résultats par le biais des
paramètres de sortie alors que la fonction ne véhicule qu’un seul résultat.
– Retour d’appel : Une procédure exécute l’ensemble des actions de son corps et provoque le
retour à l’appelant. Une fonction fait la même chose mais en plus elle véhicule un résultat
par le biais de son nom qui est considéré par l’appelant comme une variable utilisable
dans toute expression de type compatible.

8.7 La récursivité
Un problème récusrsif est un problème qui fait appel à lui même pour résoudre un problème.
Ce phénomène est souvent rencontrer dans les objets, les mathématiques, les programmes, les
structures de données...
exemple une liste est composée d’un élément et d’une autre liste.
le successeur d’un entier naturel est un entier naturel.
Si le prblème a une structure récursive, on utilise pour sa résolution des algorithmes récursifs.
exercice 8 calcul de X y
Algorithme 8.3 Algorithme de calcul de X y

FONCTION puissance(x, y :entier)
VAR
DÉBUT
si (y=0) alors
retourner(1) ;
sinon
retourner(x*puissance(x, y)) ;
fsi
FIN
exercice 9 calcul de calcul du PGCD
Algorithme 8.4 Algorithme de calcul du PGCD

FONCTION PGCD(a, b :entier)
VAR
DÉBUT
si (b=0) alors
retourner(a) ;
sinon
retourner(PGCD(b, a MOD b)) ;
fsi
FIN
8.8 Conclusion
La méthode d’analyse descendante consiste en un raffinement successifs en partant d’un
problème complexe que l’on décompose en sous-problemes moins compliqués. On décompose

alors ces problèmes en sous-problèmes de plus en plus simples, jusqu’à parvenir à des pro-
blèmes tellement élémentaires que la solution en est évidente. En algorithmique, on utilise les
procédures et les fonctions pour aboutir à ce but.

Bibliographie
[1] Sophie Boutin, Sylvie Tormento. “Algorithmes Cours et Exercices”, Edition Bréal, 1994
[2] Mossaab BOUKHCHIM (2006), notes de cours “Algorithmique –Niveau 1”, ISET de Kef
[3] Jacques Courtin, Irène Kowarski “Initiation à l’algorithmique et aux structures de données”,
Collection : Sciences Sup, Dunod 1998 - 2ème édition -Tome 1- 368 pages
60

Algorithmique 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algorithmique 1

Transféré par

Droits d'auteur :

Formats disponibles

Table des matières

Table des matières i

2 Les types de données simples et les actions élémentaires

3 Les structures conditionnelles 16

3.2.1 Le conditionnel simple . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4 Les structures itératives 22

6 Les chaînes de caractères 42

Hana JOUINI page ii Algorithmique Niveau 1

8 Les procédures et les fonctions 53

Hana JOUINI page iii Algorithmique Niveau 1

1.1 modélisation d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

3.1 modélisation de la structure conditionnelle simple . . . . . . . . . . . . . . . . 17

4.1 Modélisation de la boucle Pour . . . . . . . . . . . . . . . . . . . . . . . . . . 24

8.1 Analyse descendante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

2.1 Algorithme moyenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Objectifs et plan du chapitre

1.1 Notion d’un algorithme

1. Délimiter le problème en spécifiant les résultats souhaités.

F IGURE 1.1 – modélisation d’un algorithme

1.2 Les caractéristiques d’un algorithme

Hana JOUINI page 2 Algorithmique Niveau 1

1.3 De l’algorithme au programme

F IGURE 1.2 – de l’algorithme au programme

Hana JOUINI page 3 Algorithmique Niveau 1

1.4 Structure générale d’un algorithme

exemple : LIRE (), ECRIRE (), DEBUT, FIN . . ...

Hana JOUINI page 4 Algorithmique Niveau 1

F IGURE 1.3 – structure d’un structogramme

1.4.2 Structure d’un algorithme

Hana JOUINI page 5 Algorithmique Niveau 1

Hana JOUINI page 6 Algorithmique Niveau 1

Les types de données simples et les actions

Objectifs et plan du chapitre

2.2 Les variables et les constantes

NB : Le nom de la variable doit commencer obligatoirement par une lettre.

2.3 Les types simples

Hana JOUINI page 8 Algorithmique Niveau 1

– La forme d’un réel doit comporter obligatoirement un ’ . ’ et au moins un chiffre avant et

– Le type caractère comprend :

Hana JOUINI page 9 Algorithmique Niveau 1

Les opérations sur les types

Hana JOUINI page 10 Algorithmique Niveau 1

2.4 Les expressions arithmétiques et logiques

2.4.2 Les expressions logiques

Hana JOUINI page 11 Algorithmique Niveau 1

2.4.3 Evaluation d’une expression

2.5 Les instructions élémentaires

2.5.1 L’instruction de déclaration

Hana JOUINI page 12 Algorithmique Niveau 1

2.5.2 L’instruction d’affectation

2.5.3 L’instruction de lecture

Hana JOUINI page 13 Algorithmique Niveau 1

Algorithme 2.1 Algorithme moyenne

Hana JOUINI page 15 Algorithmique Niveau 1

Les structures conditionnelles

Objectifs et plan du chapitre

3.2 la structure si. . .alors

F IGURE 3.1 – modélisation de la structure conditionnelle simple

Hana JOUINI page 17 Algorithmique Niveau 1

Algorithme 3.1 Algorithme valeur absolue

3.2.2 Le conditionnel généralisé

F IGURE 3.2 – modélisation de la structure conditionnelle généralisée

Hana JOUINI page 18 Algorithmique Niveau 1