Support ALGORITHME2023-2024

Université de Labé Support de Cours d’Algorithmique1- Par M.K.
DELAMOU édition 2023 Tel 622088864
Table des matières

Chapitre 1 INTRODUCTION A LA PROGRAMMATION ............................................................................................ 2
Chapitre 2 LES DECLARATIONS.............................................................................................................................. 6
Chapitre 3 LES ENTREES SORTIES CONVERSATIONNELLES .................................................................................. 17
Chapitre 4 LES INSTRUCTIONS DE CALCUL ET D’AFFECTATION .......................................................................... 19
Chapitre 5 LES STRUCTURES ALGORITHMIQUES ................................................................................................. 22
Chapitre 6 LES PROCEDURES ET LES FONCTIONS ................................................................................................ 32
TRAVAUX DIRIGES N°1 ........................................................................................................................................ 43
TRAVAUX DIRIGES N°2 ..................................................................................................................................... 45
TD N°3 LES PROCEDURES ET LES FONCTIONS ..................................................................................................... 49
BIBLIOGRAPHIE ................................................................................................................................................... 51
1
Université de Labé Support de Cours d’Algorithmique1- Par M.K. DELAMOU édition 2023 Tel 622088864
Chapitre 1 INTRODUCTION A LA PROGRAMMATION

Le cours d’Algorithme occupe une place prépondérante en informatique surtout dans le domaine
de la programmation des ordinateurs. Sa syntaxe a servi de base à de nombreux langages.
Le but de ce cours est de vous apprendre à programmer en estiment les concepts
fondamentaux à l’aide d’un pseudo-code. Cela vous permettra de rédiger des programmes en
privilégiant l’aspect Algorithmique et la technicité d’un langage donné.
Pour bien comprendre cette notion de programmation, nous nous baserons sur un exemple pris
dans la vie courante.
A) Exemple : Préparation d’un gâteau appelé Kouign-Amann
Le Kouign-Amann est un délicieux gâteau très facile à confectionner.
La présentation de la recette se fera en deux parties :
D’abord les ustensiles à utiliser et les différents ingrédients entrant dans la confection de cette
pâtisserie, ensuite les actions à accomplir pour obtenir le produit final.
Partie I : Les ustensiles et les ingrédients.
- Une planche de cuisine
- Un rouleau à pâtisserie
- Un moule à gâteau
- Un four
- 450g de farine
- 300g de beurre
- 200g de sucre
- 20g de levure boulangère
- Une pincée de sel
- 3 cuillérées de d’eau
Partie II : La Préparation
- Faire une pâte à pain avec : la farine, l’eau, le sel et la levure ;
- Laisser reposer 30 min
- Ajouter 180g de sucre
- Ajouter le beurre
- Mettre la pâte dans le moule beurré
- Faire cuire à 220° durant 30mn,
- Saupoudrer avec les 20g de sucre
- Servir tiède
B) Analyse de la recette
La partie I donne une liste d’éléments jugés indispensables à la préparation d’un kouign-amann.
Chacun de ces éléments constitue un objet de la recette.
-La collection de tous les objets (ingrédients et ustensiles) sera appelé environnement de la recette.
2
Nous dirons donc que l’ensemble des éléments nécessaire à l’exécution du travail (préparation du
gâteau) est appelé environnement de ce travail.
La partie 2 est constituée d’une série de tâche qui, une fois accomplies, aboutissent à l’obtention
d’un kouign-amann. Chaque tâche sera désignée par le terme action.
Si on applique les mêmes actions sur le même environnement en tout lieu et à tout instant, on obtient
toujours le même résultat.
On vient de définir ce que l’on appelle un algorithme de confection d’un kouign-amann.
C’est donc l’énoncé d’une séquence d’action réalisant la confection de ce gâteau.
Algorithme= environnement + action
Le kouign-amann se déroule en 1h 10mn) 10mn pour préparer la pâte, 30mn de pause et 30mn de
cuisson). C’est lent mais c’est un temps fini.
Un algorithme doit aboutir à un résultat en un temps fini.
L’algorithme ainsi défini est écrit en français. Il aurait par l’être en breton, en arabe, en chinois
le résultat ne serait pas modifié pour autant . On appelle cette langue le langage algorithmique
Nous dirons donc qu’un algorithme est écrit dans un langage.
Le processus ou l’algorithme ainsi défini s’adresse à tout individu comprenant ce langage, et
ayant à sa disposition tous les objets de l’environnement et étant capable d’accomplir toutes les
actions de la préparation. Cet individu sera appelé le processeur.
Processeur= exécuteur de l’algorithme.
1.1. Définition de quelques concepts :
- L’environnement : ensemble des objets nécessaires à l’élaboration d’un algorithme.
- Objet : Un élément de l’environnement pris individuellement.
- Action : évènement qui modifie l’environnement.
- Algorithme : un moyen de description des étapes à suivre pour résoudre un problème ou
encore l’ensemble des actions appliquée à un environnement bien précis afin d’obtenir un
résultat.
- Processeur : Toute entité capable de comprendre l’énoncé d’un problème et
d’exécuter le travail demandé.
- Programmer = écrire des algorithmes.
- Un programme est une suite d’instructions enregistrées dans la mémoire d'un ordinateur lui
permettant d'exécuter des tâches données.
- Programmeur= Toute personne capable d’écrire des programmes

- Un langage de programmation est un ensemble d’instructions et de règles
syntaxiques compréhensible par l’ordinateur et permettant de créer des programmes.
Autrement dit c’est un logiciel permettent de traduire une écriture algorithmique en un
code compréhensible par la machine.
- Un logiciel est un programme de traitement de l'information contenant les procédures
et les données nécessaires à une application
3
1.2. Historique
Le mot algorithme n’est pas dérivé d’un mot latin ou grec, mais d’une contraction et d’une
dérivation du nom du mathématicien arabe al-Khawarizmi qui publia deux livres importants : l’un
sur l’arithmétique et l’autre sur « l’action de faire passer et d’agencer les parties d’un tout » (titre
original : Kit ab al-jabrwalmuqabala). Trois siècles plus tard, le livre, traduit en latin, porta le
nom Algorismus. La première définition du mot algorithme, dans son sens actuel, a été donnée par
le mathématicien russe Markov : « Tout ensemble de règles précises qui définit un procédé de
calcul destiné à obtenir un résultat déterminé à partir de certaines données initiales. »
Les algorithmes sont constitués par un ensemble de règles précises et compréhensibles par tous.
Ils s’appliquent à des données qui peuvent changer et élaborent les résultats en fonction des
données initiales.
1.3. Lien entre Algorithme, Programme et langage de programmation :
Pour expliquer les liens qui se trouvent entre ces trois notions il serait judicieux de passé à un
schéma.
Décrire les étapes à suivre Tradition en langage compréhensible

Problème Programme
Algorithme )
Pour obtenir un résultat par la machine (pascal, C, C++, VB
1.4. Objet de la programmation
Soit un travail que l’on veut effectuer à l’aide d’un processeur donné. L’objet de la
programmation est d’établir une séquence d’actions pouvant être exécutées par le processeur et
qui réalisent ce travail.
La programmation est constituée de deux phases :
• La résolution du problème, c'est-à-dire la détermination d’un algorithme réalisant le

traitement ;
•L’adaptation de l’algorithme au processeur. Elle est réalisée par la codification de
l’algorithme par le biais d’un langage donné spécifique du processeur utilisé. La résolution
du problème est l’étape la plus difficile. Il n’en reste pas moins que l’intelligence et
l’intuition jouent un rôle, en particulier dans la formulation des solutions élégantes et
efficaces. Les ordinateurs ne pouvant exécuter directement les algorithmes sous leur forme
littérale, il est nécessaire de les codifier dans un langage approprié appelé langage de
programmation (ensemble d’instructions et de règles syntaxiques compréhensible par
l’ordinateur et permettant de créer des programmes).
Généralement ce travail ne présente pas de difficultés majeures et fait intervenir principalement
des mécanismes de traduction qui sollicitent peu de l’intelligence de la personne qui codifie. En
revanche, dans une problématique de gestion de stock, il faudra peut-être utiliser des bases de
données, des instructions de tri et de calcul.
4
1.5. Double problématique de l’algorithmique

a) Trouver une méthode de résolution (exacte ou approchée) du problème.
–Soient trois nombres réels a, b et c, quelles sont les solutions de l’équation ax²+bx+c=0 ?
(Résultat bien connu.)
–Soient cinq nombres réels a, b, c, d et e, quelles sont les solutions de l’équation
ax5+bx4+cx3+dx²+ex+f=0 (Pas de méthode générale)
b) Trouver une méthode efficace.
Savoir résoudre un problème est une chose ; le résoudre efficacement en est une autre …
5
Chapitre 2 LES DECLARATIONS

Définition : la déclaration est l’acte par lequel on fait connaître au processeur les différents
éléments ou objets utilisés pour l’élaboration de l’algorithme.
2.1. Les Types de données
Un algorithme manipule des données. Pour les utiliser, il faut réserver des emplacements mémoire
dont la taille dépend de leurs types. Le processeur s’en charge de la représentation interne des
données.
2.1.1. Classification des types de données
On distingue en générale deux catégories :
- Les caractères
- Les numériques
Une troisième catégorie sera nécessaire :
- Les booléens
2.1.2. Définition
Un type est un attribut qui nous renseigne sur la nature d’un objet et sur tout le genre d’action
qu’on peut lui appliquer. En d’autres termes les types de donnée représentent le domaine de
définition des variables.
Il existe deux catégories de types : les types de bases ou prédéfinis et les types construits
2.1.3. Les types de bases ou prédéfinis
Ce sont les types qui sont directement reconnus par le processeur pendant la déclaration des
objets. Nous avons comme types de base :
2.1.3.1. Les Caractères :
Un caractère est un élément de l’alphabet du processeur. A chaque caractère est associée une
valeur dans son code choisi. Il faut distinguer les caractères de contrôle des caractères ayant une
représentation graphique. Pour ces derniers, le symbole graphique n’est pas toujours obtenu
depuis le clavier.
Donc on peut différencier :
- Les caractères ayant une représentation graphique :
Manipulable directement à partir du clavier tels que :
- Les lettres majuscules, minuscules et accentués
- Les chiffres de 0 à 9
- Les symboles de ponctuation et d’autres caractères spéciaux tels que : + - * /, & ; # | \ { }
[ ] (=) @ ’^….
Non manipulable à partir du clavier
- Les caractères semi graphiques qui permettent de dessiner un tableau par exemple.
2.1.3.2. Les numériques (les entiers et les réels)
6
Problème :
Il existe une infinité de nombres. En mathématique, on distingue :
- Les entiers naturels : 0 1 2 3 4 …
- Les entiers relatifs : -4 -3 -2 -1 0 1 2 3 4…
- Les réels : 1 1.1 1.11 1.111…
- Entre deux nombres quelconques, il existe une infinité de nombres réels
En informatique, pour les représenter, on est limité par la capacité de la machine.
Objectif : Il s’agit de trouver une représentation interne des nombres
Solution : il faut adopter un codage différent pour les entiers et pour les réels :
- Ne représenter qu’un sous-ensemble des entiers relatifs ; - Réaliser

une approximation pour les nombres réels.
Exemple : l’amplitude des nombres entiers relatifs représentés dépend de la taille de

l’emplacement réservé.
Sur 2 octets : -215<=Z<=+215-1 -32 768<=Z<=+32767
2.1.3.3. Les Booléens
Il arrive souvent aux programmeurs de se poser des questions pour lesquelles ils s’attendent à
une réponse sous la forme de « Oui » ou de « Non ». Il serait donc commode de disposer d’un
équivalent qui sera représenté par les booléens. L’ensemble des booléens comporte deux valeurs
notées : VRAI et FAUX.
2.1.4. Etude détaillée des types de bases
Table2.1
2.1.4.1. Les Caractères
Notation du type Car

Ensemble de valeurs Tout caractère
Notation des valeurs Entre apostrophe exemple :’A’
Opérateurs de relation =, <>, <,>, <=,>= selon le code
Exemple: ‘A’<’B’; ‘A’<’a’
Fonctions Ord (car) ; Car (entier de 0 à 255)
Ord (‘A’)=65 ; Car(65)=’A’ dans le code ASCII
A chaque caractère est associé un numéro correspondant au rang de ce symbole dans la séquence
conventionnelle du code utilisé par la machine.
7
Table2.2
2.1.4.2. Les entiers
Notation du type Entier

Ensemble de valeurs Sous ensemble des éléments de Z
Notation des valeurs Exemple : [-3768..+32767] -1, 1 ou +1, 0 mais pas
33000 !
Opérateurs + ;-,*
Opérateurs euclidien Div, Mod
Puissance ** ou ^
Opérateurs de relation =,<>,<,>,<=,>=
Fonctions abs (entier) valeur absolue renvoie la valeur absolue
d’un entier ; Carré () renvoie le carré d’un nombre.
Table 2.3
2.1.4.3. Les réels
Notation du type Réel
Ensemble de valeurs Représentation approchée d’une partie des nombres
réels
Notation des valeurs Exemple -3; 3.14 ; 1.12E+4 ; 314E-2
Opérateurs + ;-,*,/
Puissance ** ou ^
Opérateurs de relation =,<>,<,>,<=,>=
Fonctions abs() ; Carré() ; Rac2() ; sin() ; cos(); Tang() ;
arrondi() ; tronc() arrondi (4.45)=4 ; arrondi
(4.56)=5 tronc (4.45)=4 ; tronc (4.56)=4
arrondi (-2.77)=-3 tronc (-2.77)=-2
Table2.4
2.1.4.4. Les booléens
Ce type, appelé aussi type logique dans d’autres langages n’apparait pas d’emblée comme aussi
nécessaire comme les autres types simples que nous venons d’étudier.
Notation du type booléen
Ensemble de valeurs Vrai ou Faux ; Oui ou Non ; 0 ou 1
Opérateurs logiques Non, ET, OU,…..
Opérateurs de relation =,<>
8
Table de vérité des opérateurs logiques
Soient deux propositions P et Q ; nous avons les tables de vérités suivantes :
Table2.5
Opérateur NON Opérateur ET Opérateur OU
P NON(P) P Q P et Q P Q P ou Q
V F V V V V V V
F V V F F V F V
F V F F V V
F F F F F F
2.1.5. Les types construits

Ce sont les types définis par le programmeur à partir des types de bases ou des types construits et
définis préalablement : comme type construit nous avons :
2.1.5.1. Le type chaine de caractères
a) Définition
C’est une succession de caractères pris dans l’ordre de l’alphabet du processeur.
Ce type est utilisé pour le traitement des données non numériques.
Remarque : il faut au moins deux caractères pour avoir une chaine de caractère.
Exemple : ‘Il’ ;’liste’ ;’total à payer’.
Cas particulier : si on veut écrire une chaine comportant l’apostrophe, il faut doubler
l’apostrophe au niveau de l’élision ‘. Exemple : ‘j’ai cogné l’’éléphant’
b) Syntaxe :
Type nomtype=chaine (taille)
Type : mot clé indiquant la création d’un nouveau type ;
Nomtype : c’est le nom du nouveau type ;
Taille : est le nombre de caractères devant constituer la chaine
Exemple : Type chainelong=chaine(30);
Nomville=chaine(20) ;
c) Fonctions prédéfinies
Les fonctions prédéfinies sur les chaines sont des outils offerts au programmeur pour lui éviter de
résoudre des problèmes trop techniques et dont l’intérêt pédagogique est discutable. On présente
ces fonctions par l’étude de quelques exemples significatifs.
Les symboles utilisés dans la présentation correspondent aux données nécessaires à ces fonctions
et ils représentent :
- ch : une chaine
- ssch : une sous chaine
- lg : une longueur en nombre entier ; - num : un nombre entier ou réel. - deb : une position de
début
9
Table 2.6
➢ Les fonctions de longueur et de positionnement
Fonctions Résultat Exemple
Long (ch) Entier Long(ABCD)=5 ; long (‘’)=0
Pos (ssch, ch) Entier Pos (‘AB’,’AACABAB’)=4 ; Pos (‘x’,’abcd’)=0
La fonction long (ch) examine la chaine ch et donne la taille sous forme d’entier correspondant
au nombre de caractères contenus dans ch.
La fonction Pos (ssch, ch) correspond à un entier égal à la position du premier caractère de la
première apparition de la sous chaine recherchée dans la chaine examinée. Cet entier vaut 0 si la
sous chaine n’est pas présente
Table2.
➢ Les fonctions d’extraction :
Gauche (ch, lg) Chaine Gauche (‘ABCDE’,3)=’ABC’
Droite (ch, lg) Chaine Droite (‘ABCDE’,3)=’CDE’
Milieu (ch, deb, Chaine Milieu (‘ABCDE’, 3,2)=’CD’
lg)
Suppr (ch, deb, Chaine Suppr (‘ABCDE’, 2,3)=’AE’
lg)
Gauche : extrait, en partant du début, une sous chaine de longueur donnée
Droite : extrait en partant de la fin, une sous chaine de longueur donnée
Milieu : extrait, à partir d’une position donnée, une sous chaine de longueur donnée
Suppr : supprime, à partir d’une position, une sous chaine de longueur donnée.
Table 2.8
➢ Les fonctions de conversion

chnum (ch) Entier ou réel Chnum (‘4.25’)=4.25
Numch (num) chaine Numch (4.25)=’4.25’
La chaine ch doit, bien sur être formée uniquement des caractères composant les nombres.
Chnum() : convertit une chaine en nombre ;
Numch() : convertit un nombre en chaine.
Ces deux fonctions peuvent être utilisées pour rendre compatibles des données de type différent.
10
2.1.5.2. Le type énuméré

C’est une disposition d’un type décrit par l’ensemble des éléments de son domaine de définition.
a) Syntaxe : Type nomtype = (val1, val2, …valn) ;
Où vali sont des constantes prises dans un ensemble discret de valeurs ou des symboles
b) Exemple : Type chiffrepair= (0, 2, 4, 6,8) ;
- Type semaine= (lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, dimanche,) ;
Le processeur associe un entier ou rang à chaque valeur en fonction de sa position dans la liste.
Exemple : lundi 0 ; mardi 1 …… dimanche 6
Par ce rang, une relation d’ordre peut être définie sur les valeurs et des comparaisons peuvent être
effectuées par les opérateurs de relation. Exemple : lundi<Mardi Les fonctions pred et succ sont
aussi définies. Exemple: pred(Mardi)=lundi; succ(mercredi)=Jeudi ; Pred(lundi) et succ
(dimanche) sont indéfinis.
La fonction ord() permet de connaître la position de la valeur dans la liste. La fonction
réciproque est nommée de la même façon que le type. Exemple : Ord (lundi)=0 ;
semaine(0)=lundi ;
L’opérateur Dans traduit l’appartenance d’un élément à un ensemble.
2.1.5.3. Le type intervalle
C’est la réalisation d’un contrôle par plage de valeurs ordonnées.
a) Syntaxe : Type nomtype=binf..bsup ;
Binf et bsup sont d’un type préalablement défini appelé type hôte.
Les opérateurs du type intervalle sont les mêmes que ceux du type hôte.
b) Exemple : type entier=-32768..32767
Type Maj=’A’..’Z’
Jour=lundi..Samedi
Lundi et mardi proviennent d’un type hôte (type semaine).
Le processeur associe un entier ou rang à chaque valeur en fonction de sa position dans la liste :
A 0;Z 25.
De même que le type énuméré l’opérateur Dans traduit l’appartenance d’un élément à un
ensemble. Les fonctions pred, succ, ord et nomtype() sont aussi définie.
2.1.5.4.Le type composé ou structuré
Il nous arrive d’éprouver la nécessité de regrouper plusieurs valeurs pour caractériser une entité
particulière. Nous définissons alors une variable composée (association de plusieurs variables
élémentaires)
11
a) Syntaxe :
Type nomtype= structure
Champ1 : type1
Champ2 :type2
…………..........
Champn :typen
Fin struct ;
b) Exemple :
Type resultat=structure
Nom : chaine(23) ;
Matière : chaine(17) ;
Note : réel ;
Fin struct ;
2.1.5.5. Le type tableau
Un tableau est une collection d’objets de même type.
a) Syntaxe
Type nomtype=tableau(1..taillemax) de t.
Où taillemax est une constante déterminant la capacité du tableau ; t est un type quelconque
commun à tous les éléments de ce tableau.
b) Exemple1 Type nombre=tableau (1..20) d’entier
Nombre est un tableau d’entiers.
Exemple2 type collection=tableau(1..50) de resultat ;
Collection est un tableau de type résultat avec resultat comme nom d’une structure.
2.2. OBJET
2.2.1. Définition : un objet est toute unité mémoire manipulé par un langage. Il est caractérisé par
un nom et un type.
- Un objet simple correspond à un emplacement simple
- Un objet composé correspond à plusieurs emplacements
A tout objet est associée une valeur.

2.2.2. Notion de contenant/contenu
Pour chaque objet, il faut distinguer :
- Le contenant : l’adresse
- Le contenu : la valeur stockée
Exemple : Age 26
Contenant Contenu
L’adresse est confondue avec le nom.
12
a) Nom : au niveau du programme, on préfère manipuler un nom plutôt qu’une adresse. Le

programmeur choisit judicieusement un nom pour chaque objet. Pour le processeur, ce
nom équivaut à l’adresse physique.
b) Type : pour chaque objet, il faut choisir un type. Cela permet au processeur de choisir la
taille de l’emplacement mémoire et d’effectuer un contrôle de type lors du rangement d’une
valeur.
Le processeur se chargera du contrôle de la compatibilité des opérations effectuées avec les types
des objets manipulés.
II.2.3 Variables et Constantes
Au cours d’un programme, le contenu d’un objet peut être :
- Modifiable : c’est une variable
- Non modifiable : c’est une constante Le programmeur doit d’abord faire la liste de tous les
objets dont il a besoin dans son programme. Pour chaque objet, il doit discerner ceux dont le
contenu va varier de ceux dont le contenu sera stable.
L’ensemble de ces étapes descriptives s’appelle la déclaration.

Avant toute manipulation sur un objet, il faut le déclarer.
2.2.3. Les Variables

Un objet dont le contenu peut être modifié est appelé variable
a) Syntaxe : var nom_var : nomtype
Var est le mot clé indiquant qu’on effectue une déclaration de variable : la réservation et l’attribution
d’un nom à une cellule mémoire dont le contenu pourra varier.
Nom_type : est le mot clé précisant le type de variable.
Nom_var est le nom de la variable judicieusement choisi.
b) Exemple1
Var age : entier ; age peut contenir toute valeur entière
Var point : réel ; point peut contenir toute valeur réelle.
Var option : car ; option peut contenir tout caractère
Pratique : toutes les déclarations de variable sont regroupées et le mot var est mis en facteur. Les
variables de même type peuvent être déclarées ensemble et le type est mis en facteur. La virgule
sert de séparatrice.
Exemeple2 : type ch20=chaine(20) ;
Var age : entier ;
Cote, surface, volume, argent_poche : réel ;
Reussite, drapeau : booléen ;
Prenom, nom, profession : ch20 ;
Type resultat=structure
Nom : chaine(23) ;
Matière : chaine(17) ;
Note : réel ;
Fin struct ;
collection=tableau(1..50)de resultat ;
var k : collection ;
13
c) Règles de nomenclature : Vous pouvez attribuer le nom que vous voulez à vos variables
mais en respectant les règles ci-dessous :
Règle N°1 : Le nom d’une variable ne doit pas commencer par un chiffre mais peut contenir de
chiffres.
Exemple: Var 1age : entier ; Incorrecte

Var age1 : entier ; Correcte
Règle N°2 : Le nom d’une variable ne doit pas contenir d’espace.
Exemple : Var pre nom: Chaine (20); Incorrecte

Var prenom : Chaine (20) ; Correcte
Règle N°3 : Le nom d’une variable ne doit pas contenir des caractères spéciaux.
Exemple: Var n@m : Chaine (20) ;Incorrecte
Var nom : Chaine (20) ; Correcte
Règle N°4: Le nom d’une ne doit pas être un mot clé d’un langage de programmation. Exemple
:Var for: entier; Incorrecte
2.2.4. Les Constantes
Un objet dont le contenu ne peut pas être modifié est appelé constante
a) Syntaxe :
Const nom_const=valeur ; où
Const est le mot clé indiquant qu’on effectue une déclaration de constante.
Nom_const est le nom de la constante judicieusement choisi par le programmeur
Valeur : est une valeur littérale ;
b) Exemple1 : const prix_unitaire=1960 ;
Le mot const est également mis en facteur pour la déclaration de plusieurs constantes et le point-
virgule sert de séparateur.
Exemple2 const nbmois=12 ; taux =0.18 ; remise=0.05 ;
c) Utilité des Constantes : Les constantes permettent de facilité la maintenance d’un
programme au niveau des opérations de mise à jour.
2.3. Structure simplifiée d’un algorithme
L’algorithme d’un programme est organisé de la façon suivante :
• Déclaration des constantes
• Déclaration des types
• Déclaration des variables
• Définition des procédures et fonctions
• Définition du programme principal
14
Algo nom_algo ;
Début
Action1 ;
Définition du corps de l’Algo Action2 ;
……..
Fin.
Le mot clé Algo suivi d’un nom significatif annonce le début de l’algorithme.
Le mot Début correspond à la fin des déclarations et au commencement des actions.
Le mot Fin signale la fin de la description de la solution.
2.3.1. Structure
Un algorithme est découpé en deux parties :
- Les déclarations où les objets sont déclarés
- Les actions où les traitements sont décrits. C’est le corps de l’algorithme.
2.3.2. Les mots clés
Les mots clés ne peuvent pas être choisis comme identificateurs. Algo et
Début encadrent les déclarations.
Début et Fin encadrent le corps de l’algorithme. (et)
encadrent les commentaires.
Const, type et var annoncent les types de déclarations.
2.3.3. Nom de l’algorithme
Un algorithme est identifié par un nom judicieusement choisi par le programmeur ; ce mot
apparait après le mot clé Algo
2.3.4. Commentaire
Un commentaire est une partie du programme ignorée par le processeur. Il sert à renseigner le
lecteur. On utilise des commentaires pour :
- Mettre en valeur la structure du programme en plaçant des titres, -
Expliquer des traitements complexes et aider à la maintenance.
15
2.3.5. Séquentialité
Les actions s’exécutent par défaut les unes à la suite des autres dans l’ordre de leur description. La
marque de la séquentialité est le point-virgule.
Le point-virgule se place, comme séparateur, après chaque action.
16
Chapitre 3 LES ENTREES SORTIES CONVERSATIONNELLES

Tout programme a besoin de communiquer avec son utilisateur final. Nous avons souvent besoin
d’entrer les informations ou fournir des donnée à un programme via le périphérique d’entrée
standard(Clavier) ou d’Afficher des résultats sur le périphérique de sorite standard(Moniteur).
Ces actions ne seront possibles qu’en utilisant les ordres d’entrée et sortie.
3.1. Ordre de Sortie : l’instruction « Afficher »

Cette instruction permet de visualiser un ou plusieurs résultats accompagnés de message à l’écran.
a) Syntaxe : Afficher (<liste des données à afficher>)
Cette liste peut contenir :

- Une variable déclarée et affectée préalablement ;
- Une constante ;
- Une formule mathématique ;
- Un message ou chaine de caractères.
b) Exemple :
- Affichage de message : Afficher (‘Aujourd’’hui’) ;

- Affichage d’une variable : Afficher(Age) ; age est déclaré et affecté.
- Affichage d’une expression : Afficher (‘le carré de 4 est :’,4*4) ;
NB : Il conseillé de faire précéder l’affichage d’une variable par l’affichage d’un message
explicatif ;
Exemple : Affichage (‘Votre age est : ‘, age) ;
c) Mise en forme
La mise en forme est très différente d’un langage de programmation à l’autre. Il est donc difficile
de dégager les caractéristiques communes. C’est pourquoi on la définit ici de façon très succincte
d) Présentation des données numériques
Don_num [: p1[:p2]]
P1 est le nombre total de positions occupées à l’écran par le nombre. P2 est
le nombre de positions décimales du nombre.
e) Passage à la ligne
Cette instruction permet de placer le curseur sur la première colonne de la ligne suivante et s’écrit
comme suit: A_la_ligne ;
3.2.Ordre d’Entrée : l’instruction lire
Cette instruction permet d’acquérir les données du clavier au cours d’un programme.
17
a) Syntaxe
Saisir(nom_var) ou lire(nom_var) ; Où nom_var doit être :

Un nom de variable et non un nom de constante.
Le type de la valeur saisie doit être compatible avec le type de la variable déclarée.
b) Sémantique
Cette action transfère les données saisies à partir du clavier vers la mémoire centrale et permet
donc l’affectation dynamique d’un nom de variable (ou plusieurs)
- Affectation : rangement d’une valeur dans une cellule mémoire
- Dynamique : la valeur est connue au moment de l’exécution
C’est la seule action nécessitant l’intervention de l’utilisateur qui doit fournir une ou plusieurs
données.
c) Exemple :
Algo saisie ;
Var nb :entier ;
Début
Afficher(‘Donner le nombre’) ;Lire(nb) ;
Afficher(‘vous avez saisi’, nb) ;
Fin.
d) Pratique
Pour des raisons de compréhension à l’exécution, il est conseillé de faire précéder une instruction
saisir ou lire de l’affichage d’un message commentant la valeur à introduire.
18
Chapitre 4 LES INSTRUCTIONS DE CALCUL ET D’AFFECTATION

4.1.Les Opérateurs
Un opérateur est symbole qui permet d’élaborer une expression en vue d’effectuer un
calcul ou une comparaison.
L’usage des parenthèses est vivement souhaité dans le cas des expressions complexes.
4.1.1. Classification des opérateurs selon le nombre d’opérandes
On classe les opérateurs en deux catégories :

a) Les opérateurs unaires : admettant un seul opérande :
• Arithmétiques notés : +, -.
Exemple : +1 -1 ;
• Logiques notés Non.
b) Les opérateurs binaires : admettant deux opérandes :
- Arithmétiques notés : +, - ,*, /, ^, div, mod ;
- Logique notés Et Ou ;
- De comparaison notés :<<= >>= = <>
4.1.2. Négation des expressions à résultat booléen
Le tableau ci-dessous donne la négation des opérateurs de relation.
OPERATEUR NEGATION
= <>
<> =
< >=
> <=
<= >
>= <
Soient P et Q des expressions à résultat booléen, la négation des expressions suivantes est :
Non(PETQ)=Non(P) OU Non(Q)
Non(POUQ)=Non(P) ET Non(Q)
4.2. Expression
Une expression désigne :
- Une valeur affectée ou une constante,

- Une combinaison licite de variables affectées ou de constantes avec des opérateurs.
a) Exemple de syntaxe correcte
X, C, 10, 10+1, X+1 et X/3 sont des syntaxes correctes
19
b) Exemple de syntaxe incorrecte

L’expression mathématique de l’encadrement n’est pas correct car l’opérateur <= est binaire
0<=note<=20 devient (0<=note) ET (note<=20)
4.3.AFFECTATION
Une affectation consiste à attribuer une valeur à une variable.
a) Syntaxe
La syntaxe générale est la suivante :

Nomvariable  expression
Nomvariable est un nom de variable préalablement déclarée ; cela ne peut pas être une constante.
Expression est une expression qui doit être de type compatible avec le type de la variable
déclarée.
Elle peut être : une constante. Exemple : surface  10 ;
Une autre variable.
Exemple : donnee  valeurMemorise
Le résultat d’une fonction. Exemple : resultat  racine (nombre)
Un calcul portant sur ces différents éléments. Exemple : surface  PI*carre(rayon).
b) Sémantique
• Sens du transfert
Contenant  contenu
La flèche ( ) se lit « prend pour propre valeur ou reçoit la valeur».

Ainsi surface 10 se lit « surface prend pour propre valeur 10 ou surface reçoit la valeur 10 »
c) Remarque :
La confusion entre le symbole de l’égalité « = » et le symbole d’affectation est fréquente.
4.4. Compatibilité entre données de types différents.
Le résultat de l’expression doit être de type compatible avec le type de la variable réceptrice mais
un certain nombre de transferts sont cependant possibles. Le tableau suivant permet résumer les
transferts autorités.
Table 4.2 Tableau de transfert
Type de transfert Remarque
Variable Expression
réceptrice
entier  arrondi(réel) Arrondi
Entier  tronc(réel) Troncature conversion de format
Réel  entier Conversion de format
Exemple : caractère  booléen est un transfert incorrect.
Remarque : les transferts entre données de même type sont évidemment compatibles.
Entier  entier est un transfert correct.
Exemple de syntaxe incorrecte
20
Partie déclaration
Const X=10 ;
Var Y,Z :entier ; Partie
actions :
X+Y  10 ; une expression ne peut être affectée
10  X ; - une constante ne peut pas avoir une valeur ; X
10 12 ; - une constante ne peut être modifiée ;
Y=20 ; l’opérateur d’affectation n’est pas le symbole « = »mais plutôt le
symbole « »
TRAVAUX DIRIGES N°1
21
Chapitre 5 LES STRUCTURES ALGORITHMIQUES

Les structures algorithmiques sont réparties en 3 catégories :
- Les structures linéaires d’opération ;
- Les structures alternatives
- Les structures itératives
5.1. Structures linéaires d’opérations

Les actions successives sont mentionnées les unes après les autres.
Syntaxe
Action1
Action2
……….
Actionn
Remarque : dans la suite, la notation « actions » ou « actionn » représentera une succession

d’actions comme ci-dessus.
5.2. Structures alternatives ou conditionnelles

Les Algorithmes que nous avons étudiés jusqu’ici étaient des Algorithmes à déroulement
linéaire ; c’est-à-dire qu’à l’exécution toutes les structures sont exécutées sans saut. Les
algorithmes que nous allons voire dorénavant serons des Algorithmes à déroulement non linéaire
c’est-à-dire que certaines instructions seront exécutées d’autre ne le seront pas.
Les structures conditionnelles vont nous permettre de mettre en place des Algorithmes à
déroulement non linéaire.
5.2.1. La structure alternative simple
C’est une instruction qui nous permettra d’exécuter une ou plusieurs actions lorsqu’une condition
est vraie. Lorsqu’une condition n’est pas vraie la structure conditionnelle simple n’agira pas.
a) Syntaxe :
Si condition alors
Actions
Fsi ;
SI repère le début de la structure conditionnelle et Fsi repère la fin de la structure
conditionnelle
Alors marque la fin de l’expression booléenne et le début des actions condition :
expression logique encore appelée expression booléenne, est une expression à résultat
booléen.
Actions : représente une ou plusieurs actions.
22
b) Exemple
Ecrire un algorithme qui accorde une remise de 5% si la somme des achats dépasse 100F
Algo prix ;
Const min=100 ; R=0.05 ; Var sa
:réel ;
Début Afficher (‘donner la somme des

achats’) ;
Lire(sa) ;
Si sa>min alors
Sa  sa-sa*R ;
Fsi ; Afficher(‘La somme à payer est : ’,sa :10 :0,’FG’) ;
Fin.
5.2.2. La structure alternative complète

La structure conditionnelle simple nous a permis d’exécuter un certain nombre d’action lorsque la
condition est vraie mais rien n’a été dit dans le cas où la condition est fausse. La structure
alternative complète quant à elle s’intéresse aux deux cas c’est-à-dire l’ensemble des actions à
exécuter lorsque la condition est vraie et l’ensemble des actions à exécuter lorsqu’elle ne l’est
plus.
a) Syntaxe
Si condition Alors
Action1 ;
Sinon
Action2
Fsi ;
SI repère le début de la structure conditionnelle.
Fsi repère la fin de la structure conditionnelle.
Alors et Sinon encadrent la suite des actions exécutées si la condition est vraie.
Sinon et Fsi encadrent la suite des actions exécutées si la condition est fausse.
Expr_log est une expression à résultat booléen.
Actionsi représente une ou plusieurs actions.
Si la condition est vraie, exécuter la suite d’actions correspondante située après le mot Alors ;
Si la condition est fausse, exécuter la suite des actions alternative située après le mot Sinon qui
vient compléter la structure.
b) Exemple
Un permis de conduire est accordé à tout chauffeur dont le nombre de points est supérieur ou égal à
120. Rédige un algorithme de ce travail.
23
Algo permis
Const point_min=120 ;
Var points: entier ;
Debut
Afficher(‘Donner les points obtenus’);
Lire(points) ;
Si points>=point_min alors
Afficher(‘Admis’)
Sinon Afficher(‘Refusé’) ;
Fsi ;
5.2.3. La structure emboîtée

a) Limite de la structure conditionnelle simple.
Exemple afficher les mentions à un examen.
Si note>=16 alors afficher(‘Très bien’)Fsi ;
Si (note>=14) et (note<16) alors afficher(‘Bien’) ;fsi ;
Si (note>=12) et (note<14) alors afficher(‘Assez Bien’) ;fsi ;
Si (note>=10) et (note<12) alors afficher(‘Passable’) ;fsi ;
Si (note<10) alors afficher(‘Redouble’) ;fsi ;
b) Objectif
Il faut éviter de tester une condition puis sa négation.
c) Solution Pour une note valide, une seule possibilité sera atteinte, elle conditionnera
l’affichage de la mention correspondante. Il convient donc de ne plus se poser des
questions sur la valeur de la note dès qu’elle est connue. Pour réaliser ces optimisations il
faut :
- Emboîter les structures conditionnelles
- Définir la portée de chaque expression logique,
- Délimiter le bloc d’actions soumis à chaque condition.
24
d) Syntaxe
Si (condition1) Alors
Alterne1 Action1
Sinon Si (condition2) Alors
Alterne2 Action2
Sinon Si (condition3) Alors
Alterne3 Action3
…………………………………………………..
Sinon Si condition n Alors
Alternen Actionn
Fin Si ;
Fin Si ;
Fin Si ;
Fin Si ;
e) Exemple
Algo mention ;
Var note : réel ;
Début
Afficher (‘Saisir un note’) ;
Lire(note) ;
Si note>=16 C1
Alors afficher (‘Très Bien’) A1
Sinon Si note>= 14 C2
Alors afficher (‘ Bien’) A2
Sinon Si note>= 12 alors C3
a afficher (‘ Assez Bien ’) A3
Sinon Si note>= 10 C4
Alors afficher (‘ Passable’) A4
Sinon afficher(‘Refus’) A5
Fsi ;
Fsi ;
Fsi ;
Fsi ;
25
f) Interprétation sémantique
Conditions C1 NonC1 NonC1 NonC1 NonC1
C2 NonC2 NonC2 NonC2
C3 NonC3 NonC3
C4 NonC4
A A1 X
C A2 X
T A3 X
I A4 X
O A5 X
N
S
Remarque
Le décalage augmente la lisibilité pour le programmeur, mais ne présente pas de valeur
sémantique pour le processeur.
La règle du processeur est :
Le Sinon se rapporte au dernier alors non déjà apparié.
Au- delà de 3 imbrications, le programme devient illisible, une solution sera apportée
ultérieurement.
g) Importance du mot clé Fsi

Comparer ces deux structures
A) B)
Si C1 alors Si C1 Alors
Si C2 Alors Si C2 Alors
A1 A1
Fsi ; Sinon A2 ;
Sinon A2 Fsi ;
Fsi ; Fsi ;
Sans le mot clé Fsi, les 2 structures seraient identiques ; l’interprétation serait ambiguë
Interprétation :
A1 est exécutée si C1 et C2 A1 est exécutée si C1 et C2
A2 est exécutée si C1 et nonC2 A2 est exécutée si non C1
5.2.4. La structure à Choix multiples
C’est un cas particulier de l’emboitement. Elle permet de simplifier la structure d’emboitement en
permettant d’exécuter un ensemble d’instructions selon :
Une Valeur,
Une liste de valeur ou un intervalle de valeur.
On peut analyser les différentes valeurs que peut prendre une variable et les regrouper en fonction
des actions qu’elles conditionnent.
26
a) Syntaxe
Cas expr Selon
Val1 : Action1 ;
Val2 : action2
……………….
Valn : actionn
Autre : actionn+1 ;
Fincas ;
Cas et Fin Cas repère le début et la fin de la structure de choix multiple
expr est une expression évaluable.
Vali est une liste ou un intervalle
Actionsi est une ou plusieurs actions
Autre est une close optionnelle.
b) Exemple :
Exemple : Affichage de la nature d’un caractère

Algo caractere ;
Var c : car (caractère saisi au clavier)
Début
Afficher (‘Taper un caractère‘)
lire (c)
Cas c selon
‘A’..’Z’ : afficher (‘Lettre majuscule’)
‘a’..’z’ : afficher (‘Lettre minuscule’)
‘0’..’9’ : afficher (‘Chiffre’)
Autre : afficher (‘Ni Lettre ni Chiffre’)
FinCas ;
Fin.
Remarques
Seuls les types : ordinaux (intervalle), entier, caractère et énumérés sont acceptés par la variable
du cas.
c) Schéma équivalent
On a l’équivalence entre les schémas suivants :
27
a) Traduction du cas avec l’option autre.
Cas expr selon Si expr =e1 alors

e1: A1 A1
e2 : A2 sinon si expr=e2 alors
A2
…………. ……………………..
en : An sinon si exprn alors
An
Autre : An+1 Sinon
FinCas Fsi ;
Fsi ;
Fsi ;
b) Traduction du cas sans l’option autre
Cas expr selon Si expr =e1 alors

e1:A1 A1
e2 :A2 Sinon si expr=e2 alors
A2
……………………………… ……………..
en : An Sinon si expr=en alors
An
Fincas ; Fsi ;
Fsi ;
Fsi ;
5.3. Structures Itératives
Définitions : une structure itérative est une structure permettant de répéter une séquence
d’instructions à un nombre de fois fini. Il existe deux types d’itérations.
- Les itérations dont le nombre de tours est connu à l’avance ;
- Les itérations dont le nombre de tours est inconnu à l’avance mais qu’on pourra calculer après
exécution.
5.3.1. La boucle Répéter…. Jusqu’à…
Cette boucle correspond à l’itération dont le nombre de tours n’est pas connu d’avance. Les
instructions sont exécutées tant que la condition est fausse.
Pour la 1ère itération :
Quelle que soit la véracité de la condition les instructions sont exécutées.
Une action ou groupe d’actions est exécuté répétitivement jusqu’à ce qu’une condition soit
vérifiée.
28
a. Syntaxe
Répéter
Action1 ;
Action2 ;
………..
Actionn
Jusqu’à condition ;
Répéter et Jusqu’à condition encadrent la suite d’actions à répéter.
Actioni est une suite de 1 ou plusieurs actions. Ces actions doivent modifier la valeur de la
condition.
Condition est le mot repérant l’expression logique.
b. Sémantique
La structure itérative permet la répétition d’une suite d’actions, un nombre fini de fois.
c. Exemple
Algo multiplication
Var i : entier ;
Début
i 1 ;
Répéter
Afficher(‘2* ’,i ,’= ’,2*i) ;
i  i+1;
Jusqu’à i>10;
Fin.
Remarque: la vérification de la condition s’effectue après les actions. Celles-ci sont donc
exécutées au moins une fois.
5.3.2. La boucle Tant que ..... Fin tant que.

Une action ou un groupe d’actions est exécutée répétitivement tout le temps où une condition est
vraie.
a. Syntaxe :
Tant Que condition faire
Action1 ;
Action2 ;
………..
Actionn ;
Fintq ;
b. Exemple
Reprenons la table de multiplication avec la boucle tant que
29
Algo multiplication
Var i : entier ;
Début i  1 ;
Tant que <=10 faire
Afficher(‘2* ’,i ,’= ’,2*i) ;
i i+1;
Ftq;
Fin.
Remarque la vérification de la condition s’effectue avant les actions. Celles-ci peuvent donc ne
jamais être exécutées.
NB : La condition d’arrêt d’une boucle est très importante en tel point qu’elle évite la présence
d’une boucle infinie dans un programme.
On appelle de variable de condition la variable sur laquelle est basée la condition de la boucle. Au
niveau des deux boucles (Répéter et Tant que) cette variable connait trois étapes dans la boucle à
savoir :
- L’initialisation ;
- L’incrémentation ;
- Le test de la condition de sortie.
Ces trois étapes sont nécessaires pour le bon déroulement de la boucle.
5.3.3. La boucle Pour…Fin ;

Cette boucle correspond à une itération dont le nombre de tour est connu à l’avance.
a) Syntaxe
Pour indice de valdebut à valfinale faire
Actions
Finpour ;
Pour et Finpour délimitent les actions appartenant à la boucle ;

Indice est la variable de parcours
Valdebut et valfinale sont la première et la dernière valeur prise par la variable indice. Actions
est une ou plusieurs actions. Ces actions ne modifient pas la valeur de la variable indice associée à
la boucle, mais l’utilise éventuellement.
c) Sémantique
La boucle Pour permet d’effectuer le traitement un nombre de fois connu avant l’exécution.
Le processeur gère un compteur qui repère la position de la valeur suivante dans l’intervalle.
Les actions de la boucle sont exécutées rigoureusement pour toutes les valeurs de l’intervalle.
Cette structure est beaucoup utilisée dans le chapitre des tableaux.
d) Exemple
30
Algo table ;
Var i :entier ;
Début
Pour i de 1 à 10 faire
Afficher (‘2*’, i,’ =’, 2*i); Finpour;
Fin.
Il existe aussi la boucle pour à pas décroissant et la syntaxe est la suivante :
Pour indice de valfinale à valdebut faire

Actions
Finpour ;
31
Chapitre 6 LES PROCEDURES ET LES FONCTIONS

Introduction : Les Algorithmes que nous avons vus jusqu’ici sont des Algorithmes
basés sur la calculabilité c’est-à-dire un ensemble d’instruction s regroupés au sein
d’un programme principal. L’objectif de ce chapitre est de nous permettre d’écrire
des programmes en utilisant une conception modulaire ; ce qui nous permettra de
s’initier à la P.O.O (Programmation,
Orienter, Objet), un style de programmation adapté par la plupart des
langages de 4 générations (C++, Java, VB.net…..).
Utilité : L’utilité des procédures et fonctions se résume en trois phases.
Economie de l’espace mémoire.
- Eviter d’écrire des séquences d’instructions identiques en différents endroits
du programme.
- Facilité la maintenance du programme.
6.1. Les Procédures

6.1.1. Définition
Une procédure est un sous-programme exécutant une tâche spécifique et retournant
ou pas des valeurs via ses paramètres. C’est aussi une suite d’action désignée par un
nom.
6.1.2. Types de procédure
Il existe deux types de procédures
Les procédures non paramétrées

6.1.2.1.
Ce sont des procédures qui n’échangent aucune information avec le programme
principal.
Principe: Il s’agit simplement de donner un nom à un groupe d’instructions.
Ensuite, l’appel de ce nom à divers endroits du programme provoque à chaque fois
l’exécution de ce groupe d’instructions.
a) Syntaxe:
Procédure Nomprocedure;
(Déclaration des variables locales)

Début
Actions
Fin
b) Exemple1
32
Algo exemple1;
VAR x, y, t : entier;
{Déclaration de la procédure Echange_xy}
Procedure Echange_xy;
Début
t  x; x y; y  t;
fin;
Début
x 3; y4;
Afficher(x, ' ', y);
Echange_xy; {1er appel de la procédure}
Echange_xy; {2eme appel de la procédure}
Fin.
c) Remarques
- Le nom de la procédure est un identificateur.
- On déclare toute procédure avant le Début du programme principal.
Exemple2 :
Procédure politesse ;
Début
Afficher (‘bonjour Monsieur donner deux entiers’);
Finproc ;
N.B Une procédure est considérée comme une instruction faisant partie du
programme principal lors de son n’appel.
Exemple
Algo somme ;
Var a, b, s :entier ;
Debut
Politesse ;
Lire(a,b);
S a+b ;
Afficher (‘La somme est : ‘,s) ;
Fin.
d) Appel de la procédure
On peut très bien appeler une procédure P1 depuis une procédure P2, mais il
faut que la procédure P1 ait été déclarée avant la procédure P2.
Exemple donnant le même résultat.
33
Algo exemple2;
VAR x, y, t : entier;
PROCEDURE Affiche_xy;
Début
Fin;
PROCEDURE Echange_xy;
Début
{Corps de la procédure}
T x; xy; yt;
Fin;
Début
X 3; y 4;
Affiche_xy;
Echange_xy;
Affiche_xy;
Fin.
Remarque
On peut aussi appeler une procédure depuis elle-même : c'est la récursivité.
6.1.2.2. Les procédures paramétrées
Avant d’approfondir l’étude des procédures paramétrées voyons ce que c’est qu’un
paramètre.
Définition d’un paramètre :
Un paramètre est une fenêtre (variable locale ou globale) qui sert d’interface entre la
procédure et le programme principal c’est-à- dire c’est une variable qui permet à la
procédure et au programme principal d’échanger des informations.
6.1.2.2.1. Pseudo-passage de paramètres
Ecrivons une procédure Produit qui calcule z = x*y.

Algo pseudo_parametre;
VAR x, y, z, a, b, c, d : réel ;
Procedure Produit ;
Début
z x*y;
Fin ;
(On veut se servir de cette procédure Produit pour calculer c = a*b et
d = (a - 1)*(b +1).)
Début
Afficher ('a b ? ');
Lire (a, b); xa; yb;
34
{données} Produit; c z; {résultat}

Xa-1; y b+1; {données}
Produit; dz; {résultat} Afficher
('c = ', c, ' d = ', d); fin.
Remarques
- L'écriture est un peu lourde.
- Il faut savoir que la procédure « communique » avec les variables x, y, z.
- Cela interdit de se servir de x, y, z pour autre chose que de communiquer avec la
procédure ; sinon gare aux effets de bord!
6.1.2.2.2. Paramétrage
La solution élégante consiste à déclarer des paramètres à la procédure :
Algo produit_parametrer;
VAR a, b, c, d : réel;
PROCEDURE Produit (E x, y : réel; S z : réel); {paramètres}
Début
Z x * y;
fin;
début
afficher ('a b ? ');
lire (a, b);
Produit (a, b, c); {passage de}
Produit (a-1, b+1, d); {paramètres}
Afficher ('c = ', c, ' d = ', d); fin.
Syntaxea)
procedure nomprocedure(liste des paramètres :type) ;
(déclaration des variables locales)
Début
(corps de la procédure)
Finproc ;
6.1.3. Type de paramètres:
Il existe deux types de paramètres :
6.1.3.1.Les paramètres formels
Les paramètres formels sont des variables qui sont utilisées lors de la création de la
procédure.
Exemple x, y et z sont des paramètres formels.
6.1.3.2.Les paramètres effectifs
Les paramètres effectifs quant à eux sont des variables qui sont utilisées lors de
l’appel d’une procédure.
35
Exemple a,b et c sont des paramètres effectifs
6.1.4. Mode de transmission des paramètres :

Il existe trois modes de transmission des paramètres
6.1.4.1. Paramètre transmit en mode Entrée ou transmission par valeur
:
Dans ce mode de transmission les paramètres effectifs fournissent leur copie à leurs
vis-à-vis formel c’est-à-dire que toute modification des paramètres formels au sein de
la procédure n’affectera pas les paramètres effectifs correspondants.
6.1.4.2. Paramètre transmit en mode Sortie ou transmission par
adresse:
Dans ce mode de transmission ce sont les paramètres formels de la procédure qui
transmettent un résultat au paramètre effectif du programme principal.
6.1.4.3. Paramètre transmit en mode Entrée/Sortie:
Dans ce mode de transmission le paramètre effectif et son vis-à-vis formel joue un
double rôle envoyer et recevoir des informations en même temps.
Notation :
E nomvar: type
Entrée
Ou
nomvar: type
S nomvar: type
Sortie Ou
nomvar: type
E/S nomvar: type

Entrée/Sortie Ou
nomvar: type
6.1.5. Liens entre les paramètres formels et effectifs :
Lorsqu’un paramètre formel est transmis en mode entrée, son vis-à-vis effectif
peut être une variable, une valeur constante ou une expression.
36
Lorsqu’un paramètre formel est transmis en mode sortie ou en entrée/sortie son

vis-à-vis effectif ne peut être qu’une variable jamais d’expression ni de valeur
constante.
Lors de l’appel d’une procédure paramétrée il y aura autant de paramètre effectif
que de paramètre formel et chaque paramètre effectif doit correspondre en type avec
son paramètre formel.
Remarque :
Les paramètres formels d’une procédure ou d’une fonction sont des variables
locales c’est-à-dire qu’elles ne sont visibles qu’à l’intérieure de la procédure ou
de la fonction. Elles restent invisibles en dehors de la procédure ou de la
fonction.
Les paramètres effectifs lors de l’appel des procédures ou des fonctions sont des
variables globales c’est-à-dire qu’elles sont visibles partout.
Après l’exécution d’une procédure ou d’une fonction l’emplacement mémoire

alloué pour les paramètres formels est automatiquement libéré.
C’est pour cette raison qu’on dit que les procédures et les fonctions économise la
mémoire.
6.1.6. Variables Locale - Variable Globale
6.1.6.1. Variables Locales
Les objets du programme qui ne sont utiles que dans la procédure peuvent être
définis dans les déclarations locales de la procédure. Ce sont les variables locales
Exemple Reprenons exemple1 et changeons l’emplacement de t :
Algo exemple 3;
Var x, y : entier ;
PROCEDURE echange_xy;
var t : entier; { Déclaration de variables locales }
Début
t  x; xy; yt;
Fin ;
Début
37
{ ... } Fin.
- Une variable déclarée localement n'existe que pendant l'exécution de la procédure,
et ne sert qu’à cette procédure.
- Le programme principal n'a jamais accès à une variable locale de procédure.
- Une procédure n'a jamais accès à une variable locale d'une autre procédure.
6.1.6.2. Variables globales
Une variable est dite globale lorsqu’elle est déclarée dans le programme principal.
Toutefois, cette variable peut être utilisée par une procédure, à cet effet elle est
locale à cette procédure. Les variables X, Y sont des variables globales.
6.1.7. Portée des variables
Les variables déclarées dans le VAR du programme principal sont appelées
variables globales. Elles existent pendant toute la durée du programme et sont
accessibles de partout.
Une variable locale a une procédure P, portant le même nom x qu'une variable
globale, masque la variable globale pendant l'exécution de P.
Exemple
PROGRAM exemple 4 ;
VAR x : entier ;
PROCEDURE Toto;
var x: entier ;
Début
x  4;
Afficher ('toto x = ', x);
Fin;
Début
X 2;
Afficher ('glob x = ', x);
Toto;
Afficher ('glob x = ', x);
Fin.
Ce programme affiche
Glob x = 2
Toto x = 4
Glob x = 2
38
6.1.8. Effet de bord
Voici le scénario catastrophe :

• On est dans une procédure P et on veut modifier une variable x locale à P.
• Il existe déjà une variable globale ayant le même nom x.
On oublie de déclarer la variable locale x au niveau de P.
- A la compilation tout va bien !
- A l'exécution, P modifie le x global alors que le programmeur ne l'avait pas voulu.
- Conséquence : le programme ne fait pas ce qu'on voulait, le x global a l'air de
changer de valeur tout seul !
Erreur très difficile à détecter ; être très rigoureux et prudent !
6.2. Les Fonctions
6.2.1. Définition :
Une fonction comme une procédure est un sous-programme qui exécute une tâche
spécifique et qui retourne une unique valeur via le nom de la fonction.
6.2.2. Syntaxe :
Fonction Nomfonction(Liste des paramètres): type de retour
(Déclaration des variables locales)
Début
Action
Nomfonction Valeur à retourner ;
Fin
6.2.3. Appel
Contrairement à une procédure, l’appel d’une fonction ne constitue pas à lui seul
une action dans l’algorithme.
L’algorithme attend de la fonction, un résultat typé qui sera utilisé dans une
expression.
Son appel se fait par l’écriture de son nom dans l’endroit voulu du programme.
Nom_fonct (paramètre effectif) ;
Exemple
Algo addition
Var a, b, som : entier ;
Fonction somme(E n1,E n2 :entier) :entier ;
39
Var m :entier ;
Début
m a+b ;
Sommem ;
Finfonct ;
Début
Afficher (‘Donner deux entiers’) ;
Lire (a, b) ;
Som somme(a,b) ;
Afficher(‘La somme est ’, som) ;
Fin.
6.2.4. Notion d’homonyme :
Lord de l’écriture d’une procédure les paramètres formels de la procédure peuvent
avoir le même nom que les paramètres effectifs du programme principal sans pour
autant désigné le même emplacement mémoire.
Exemple : Ecrire une fonction qui permet de calculer la somme de deux entiers.
Algo Calcul ;
Var n1, n2, m : entier ;

Fonction Somme (E n1, n2: entier):Entier ;
Var s : entier ;
Début
S  n1+n2;
Somme S
Finfonct ;
Début
Afficher (‘donner deux entiers’);
Lire(n1, n2) ;
Som Somme(n1, n2) ;
Afficher (‘la somme de’,n1, ‘et de’, n2’, est:’, Som) ;
Fin
6.2.5. Types d’appel
L’appel d’une fonction se fait de deux manières :
6.2.5.1. Dans une affectation.

Exemple
Algo addition;
Var a, b, som :entier ;
Début
40

Lire (a, b) ;
Som somme(a,b) ;
Afficher(‘La somme est ’ :som) ;
Fin.
6.2.5.2. Dans une expression.

Exemple
Algo addition
Var a, b : entier ;
Début
Lire (a, b) ;
Afficher (‘La somme est : ’, somme (a, b)) ;
Fin.
Remarque Il est obligatoire que la fonction retourne un résultat dans tous les cas
sinon le résultat n’aurait pas de valeur dans les cas non prévus.
Exemple La fonction suivante est interdite :
Fonction majeur1(E age : entier) : booléen ;
Début
Si age<18 alors
Majeur1 faux ;
Fsi ;
Fin_fonct ;
Car elle ne retourne pas de valeur dans le cas l’age >= 18 ;
Aussi l’exécution de l’instruction retourne interrompt l’exécution de la fonction.
Ainsi la fonction suivante quoi que syntaxiquement correcte, retourne toujours la
valeur « vrai ».
Fonction majeur2(E age : entier) : booléen ;

Début
Si age<18 alors
Majeur2faux ;
Fsi ;
Majeur2 true ;
Fin_fonct ;
Des solutions correctes seraient les suivantes :
a) Fonction majeur1_1(E age : entier) : booléen ;

Var maj : booléen ;
Début
41
Majfaux ;
Si age>=18 alors
Maj vrai ;
Fsi ;
Majeur 1_1 maj ;
Fin_fonct ;
b) Fonction majeur1_2(E age : entier):booléen ;
Début
Si age>=18 alors
Majeur1_2 vrai ;
Sinon
Majeur 1_2 faux ;
Fin_fonct ;
La solution la plus simple et tout aussi correcte, strictement équivalente aux
précédentes serait :
c) Fonction majeur1_3(E age : entier) : booléen ;
Début
Majeur1_2 (age>=18);
Fin_fonct ;
En effet l’expression age>=18 prend la valeur « vrai » ou « faux » selon la valeur
de l’age, l’instruction conditionnelle est inutile
Différence entre procédure et fonction

6.2.6.
6.2.6.1. Paramètre d’entrée
Une procédure peut avoir des paramètres formels en mode entrée, ou entrée/sortie
Les paramètres d’une fonction sont toujours en mode entrée ;
6.2.6.2.Paramètre de sortie
La procédure peut fournir plusieurs résultats par le biais des paramètres en mode
sortie ou entrée/sortie.
La fonction ne véhicule qu’un seul résultat.
6.2.6.3. 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.
42
LES ENTREES /SORTIE ET LES CALCULS ET AFFECTATIONS
1. Ecrire un algorithme qui permet de saisir un nombre au clavier puis l’affiche à

l’écran.
2. Pour convertir des degrés Fahrenheit en degrés Celsius, on a la formule suivante :
C= 0.55556 × (F − 32) où F est une température en degrés Fahrenheit et C la
température correspondante en degrés Celsius.
a) Écrire un programme C qui convertit une température entrée au clavier
exprimée en degrés Fahrenheit et affiche une valeur approchée de la même
température en degrés Celsius. Les températures seront exprimées par des
nombres réels.
b) Même question qu’au a) pour la conversion inverse : de degrés Celsius en
degrés Fahrenheit.
3.Lorsqu’un nouvel étudiant se présente au service de la scolarité de son établissement
en vue de son inscription, il doit fournir à l’agent les renseignements suivants :
- Son nom formé de 15 caractères
- Sa date de naissance formée de 8 chiffres
- Son année de scolarité formée de 4 chiffres
- Sa spécialité formée de 10 caractères
Ecrire un algorithme permettant la saisie et l’affichage de toutes les données de
l’étudiant.
NB : la date sera affichée sous forme : jj/mm/aaaa et on utilisera un type composé ou
structuré.
4. Pour un cercle dont la valeur du rayon est lue, écrire un algorithme qui calcule et
affiche avec l’unité choisie :
- Le périmètre du cercle ;
- La surface du cercle ;
- Le volume de la sphère.
5. Le salaire net est calculé en fonction de trois paramètres :
- L’indice du salarié noté (i) ;
- La valeur point d’indice (25.60) ; noté (vpi)
- Le taux de ristourne (18%) ; noté (taux_r)
- La formule du salaire net noté (salnet) est :
43
Salnet=i*vpi+i*vpi*taux_r.
Ecrire un algorithme qui calcule et affiche le salairenet d’un employé après avoir
demandé les informations nécessaires.
6. Ecrire un algorithme qui demande à l’utilisateur les valeurs de deux variables
réelles x1 et x2 ; calcule et affiche la valeur de la distance d entre les points A
et B d’abscisse respective x1 et x2. L’algorithme le résultat de la sorte :
d(AetB)=d. (valeur à calculer)
7. Ecrire un algorithme qui demande à l’utilisateur les valeurs des coordonnées
de deux points A et B (A(xa,ya) et B(xb,yb) ) ; calcule la valeur de la
variable d1 mesurant la distance entre les points A,B de coordonnées
respectives xa,ya et xb,yb.
8. a) Etant donné une longueur, demandée à l’utilisateur et exprimée en pied et
pouce ; écrire un programme qui calcule et affiche cette longueur en pouce.
On rappelle que 1 pied=12pouces.
b) Cette fois ci on vous demande d’écrire un algorithme qui calcule et affiche la
longueur en pied et pouce sachant que l’utilisateur saisira un nombre entier en
pouce.
9. Echange du contenu de deux variables
Le but de cet exercice est d’échanger le contenu de deux variables et non
d’en intervertir l’affichage.
L’affichage de ces variables avant et après est seulement fait pour permettre
la vérification de l’échange.
En utilisant deux variables de type entier nommé N1 et N2, écrire un
algorithme qui demande à l’utilisateur un contenu différent pour ces deux
variables ; affiche dans cet ordre N1 et N2.
Intervertit le contenu de ces deux variables, puis affiche à nouveau N1 et N2.
10 Lors d’une opération de promotion, un magasin de composants hardware
applique une réduction de 10% sur tous les composants. Écrire un
programme qui lit le prix d’un composant au clavier et affiche le prix calculé
en tenant compte de la réduction.
11 Une bille de plomb est lâchée du haut d’un immeuble et tombe en chute libre.
Au bout d’un temps t (exprimé en secondes), la bille est descendue d’une
hauteur (en mètres) :
h=1/2*gt² avec g = 9.81 (exprimé en (m. s−2))
a) Écrire un programme qui calcule la hauteur descendue au bout d’un temps
t saisi au clavier.
44
b) Écrire un programme qui calcule la durée totale de la chute connaissant la

hauteur totale h de l’immeuble saisi au clavier. (On pourra utiliser la fonction
racine carrée qui calcule la racine carrée d’un nombre.)
LES STRUCTURES CONDITIONNELLES
1. Ecrire un algorithme qui calcule et affiche :

a) le reste de la division d’un nombre a par un nombre b.
b) la partie entière de la division de a par b.
2. Ecrire un algorithme qui calcule et affiche :
a) Le maximum de 4 nombres ;
b) Le minimum de 4 nombres.
3. Ecrire un algorithme qui demande à l’utilisateur les coefficients d’une
équation du 1er degré de la forme ax+b=0 ; calcule et affiche la racine
(solution) de cette équation. Etudier les cas.
4. Ecrire un algorithme qui demande à l’utilisateur les coefficients d’une
équation du 2e degré de la forme ax²+bx+c=0 ; calcule et affiche les racines
(solutions) de cette équation.
5. Une entreprise X vend deux types de produits. Les produits de type A
qui donnent lieu à une TVA à 5, 5%, et les produits de type B, qui donnent lieu
à une TVA à 19, 6%. Écrire un programme qui lit au clavier le prix hors taxe
d’un produit, saisit au clavier le type du produit et affiche le taux de TVA et le
prix TTC du produit.
6. Ecrire un algorithme qui trouve le montant net à payer par un client
sachant qu’une remise de 15% est accordée pour les clientes et 10% pour les
clients lorsque la quantité commandée est supérieure à 500 unités.
L’utilisateur saisira le nom du client ou la cliente, le sexe, la date de
commande, le numéro de facture, de téléphone, la quantité et le prix unitaire.
Le programme affichera à l’exécution les informations de la sorte.
******************Facture pour achat**************************
N° facture : 0073
Date commande : 25/07/2010
Sexe : Masculin
Nom client(e) : Delamou Koliko
Téléphone : 664722117
45
Quantité : 900kg
Prix Unitaire : 5000fg
Taux Remise : 10%
Net à payer : à calculer
NB : ces valeurs affichées sont un exemple, ne faites donc pas un algorithme
statique.
7. Une société d’assurance pratique la méthode de la franchise dite de la
variable. Le principe est simple et consiste à dire que le montant de la
franchise laissé à la charge d’un assuré doit représenter les 10% du montant
des réparations. Toute fois cete franchise ne doit descendre en dessous de
1000fg ni dépasser 4000.
Ecrire un algorithme qui demande le montant des réparations et calcule et
affiche la franchise laissée à la charge de l’assuré.
8. Écrire un programme qui lit deux nombres entiers a et b et donne le
choix à l’utilisateur :
1. de savoir si la somme a + b est paire ;
2. de savoir si le produit ab est pair ;
3. de connaître le signe de la somme a + b ;
4. de connaître le signe du produit ab.
9. Simulation d’une calculatrice très simplifiée
Ecrire un algorithme qui simule le fonctionnement d’une calculatrice très
simplifiée (seules les opérations +,*,- et / sont disponibles)
Cet algorithme saisit l’opération sous la forme
Opérande1 opérateur Opérande2=résultat
Exemple : 12*3=36
Si l’opération demandée est une division par 0, l’algorithme affiche un
message adéquat.
10. Ecrire un algorithme qui peut trouver la somme, le produit, la moyenne, le
minimum et le maximum de trois nombres réels saisis. L’utilisateur fera
son choix à travers un menu qui se présente comme suit :
1………………Somme
2………………Produit
3…………….Moyenne
4…………….Maximum
5………….....Minimum
11. Cet algorithme est destiné à prédire l'avenir, et il doit être infaillible !
46
Il lira au clavier l’heure et les minutes, et il affichera l’heure qu’il sera une minute
plus tard. Par exemple, si l'utilisateur tape 21 puis 32, l'algorithme doit répondre :
"Dans une minute, il sera 21 heure(s) 33".
NB : on suppose que l'utilisateur entre une heure valide. Pas besoin donc de la
vérifier.
12. De même que le précédent, cet algorithme doit demander une heure et en
afficher une autre. Mais cette fois, il doit gérer également les secondes, et
afficher l'heure qu'il sera une seconde plus tard.
Par exemple, si l'utilisateur tape 21, puis 32, puis 8, l'algorithme doit répondre :
"Dans une seconde, il sera 21 heure(s), 32 minute(s) et 9 seconde(s)".
NB : là encore, on suppose que l'utilisateur entre une date valide.
LES STRUCTURES ITERATIVES
Dépouillement
Ecrire un algorithme qui permet de compter le nombre de bulletins obtenu
par chaque parti. On suppose que les partis sont les suivants : PUP, PRP,
RDR, UFR, UPG. Nous conviendrons de saisir 1 pour PUP ; 2 pour PRP ;
3 pour RDR ; 4 pour UFR ; 5 pour UPG et 0 pour les bulletins nuls.
L’algorithme doit également afficher :
- Le total des suffrages obtenus ;
- Le nombre de bulletins nuls ;
- Le suffrage valablement exprimé ;
- Le suffrage obtenu par parti ainsi que le % par candidat.
Le programme s’arrêtera par la saisie d’un nombre négatif.
14. On saisit une série de notes terminée par 0. Ecrire un algorithme qui
calcule et affiche la moyenne arithmétique et le nombre de notes saisies.
Le nombre 0 permet d’arrêter la saisie.
15. Soit une suite (Un) définie par : Uo=1 et Un+1=1/2n+1 avec limite
(Un)=0 pour tendant vers l’infini. Ecrire qui calcule et affiche les termes
de cette suite jusqu’à U(n)<10-4
16. Ecrire un algorithme qui affiche les nombres pairs compris entre 2 et 100.
Le programme affichera 10 nombres par ligne.
17. Ecrire un algorithme qui test si un nombre entier positif saisi est un carré
parfait ou non. Le programme affichera la racine carrée de ce nombre si le
nombre est un carré parfait ou la partie entière de la racine carrée de ce
nombre. On obligera l’utilisateur à saisir un nombre positif.
47
18. Ecrire un algorithme qui calcule et affiche la valeur de la puissance entière

d’un entier n à la puissance p.
19. Ecrire un algorithme qui calcule la moyenne de notes fournies au clavier
avec un dialogue se présentant comme suit :
Combien de notes : 4
Note1 :12
Note2 :15.25
Note3 :13.5
Note4 :8.75
Moyenne de ces 4 notes : 12.37
20. Ecrire un algorithme qui calcule la moyenne des notes fournies avec un
dialogue de ce type :
Note1 :12
Note2 :15.25
Note3 :13.5
Note4 :8.75
Note5 :-1
Moyenne de ces 4 notes : 12.37
21. Ecrire un algorithme qui affiche un triangle rempli d’étoiles s’étendant sur
un nombre de lignes fourni au clavier par l’utilisateur.
Exemple : nombre de ligne=5
*
**
***
****
*****
22. Ecrire un algorithme qui teste si un nombre entier positif saisi au clavier
par l’utilisateur est premier ou non. On rappelle que le premier nombre
premier est 2.
23. Ecrire un algorithme qui demande à l’utilisateur son nom et affiche les
caractères composant son nom sous forme de triangle.
Exemple nom= DELAMOU et le programme affiche
D
DE
DEL
DELA
DELAM
DELAMO
DELAMOU
Utiliser la fonction d’extraction gauche.
48
24. Écrire une fonction qui calcule la somme : s = 1 + 23 + 33 + ··· + n3 en fonction

de n.
25. Ecrire un algorithme qui demande à l’utilisateur un entier n>=2 jusqu’à ce que
la reponse convienne, puis calcule les termes de la suite de fibonacci <=n.
Uo=1 ;U1=1
Un+2= Un+1 + Un
LES PROCEDURES ET LES FONCTIONS
TRAVAUX DIRIGES N° 3
1. Ecrire un algorithme qui calcule le maximum et le minimum de 4 entiers.

2. Ecrire un algorithme qui calcule le produit, la somme et le quotient de deux
entiers.
3. Ecrire un algorithme qui à partir de deux longueurs demandées à l’utilisateur
et exprimées en pied pouce, calcule et affiche la différence en pied pouce
entre ces deux longueurs. On utilisera des procédures.
4. Ecrire un algorithme qui permet de trouver tous les nombres strictement plus
petits que 1000 et dont la somme des cubes des chiffres le composant est
égale au nombre lui-même. Un tel nombre est appelé nombre d’Armstrong.
Exemple 153=13+53+33 est un nombre d’Armstrong.
Créer une procédure de décomposition d’un nombre en ses chiffres de
centaine, de dizaine et d’unité.
5. Un jeu d’allumettes se joue à deux avec la règle suivante : le jeu commence

avec un tas de 50 allumettes. Chaque joueur prend à son tour un nombre
d’allumettes compris entre 1 et 6 (dans la limite de ce qui reste disponible) et
fait ainsi diminuer le tas. Le joueur qui se trouve obligé de prendre de prendre
la dernière allumette est perdant. Ecrire un algorithme qui permet de jouer à
ce jeu. Les deux joueurs seront appelés joueur n°1et joueur n°2. Pour jouer, il
suffit de saisir un nombre dont on contrôlera la validité en utilisant une
procédure paramétrée (contrôle saisi). Avant chaque saisie on fera afficher le
nombre d’allumettes du tas restant. Lorsque le tas sera vide, on affichera
lequel des deux joueurs a gagné et au bout de combien coups.
6. On donne l’expression mathématique suivante :

49
Ecrire algorithme qui calcule et affiche Y=Y1/Y2. On écrira des fonctions

qui calculent le produit des Ai et la somme des Bj.
7. On désire convertir un nombre donné en heures et en minutes. Ecrire un
algorithme qui demande à l’utilisateur un nombre inférieur ou égal à 1439
puis le décompose en heure et minute. On utilisera une procédure de
décomposition de ce nombre.
TRADUCTION DE QUELQUES MOTS CLES EN LANGAGE C
Langage algorithmique Langage C

Constnom_const=valeur Const type nom_const=valeur
Type nom_type=chaine(taille) char nom_chaine[taille+1] ;
Type nom_type=tableau(1..namx)de t Type nom_tableau[namx]
Type nom_type=structure struct nom_structure {
Champ1:type1 ; type1 Champ1;
Champ2 :type2 ; type2 Champ2;
……………… ………………
Champn :typen typen Champn :
Fstr ; }
Var nom_var :nom_type nom_type nom_var :
Procedure nom_procedure Void nom_procedure()
Fonction nom_fonction Type nom_fonction()
Début {
Afficher/afficher a_la_ligne Printf() ou puts()
Lire/lire a_la_ligne Scanf() ou gets()
A b A =b
Si condition alors If (condition)
Action ; FSI ; {Action ; }
Si condition alors If (condition)

Action1 ; {
Action2 ; Action1 ;
………. Action2 ; ……….
Actionn ; Actionn ;
FSI ; }
50
Cas choix selon Switch(choix)

Val1 :action1 ; { Case Val1 :action1 ;
Val2 :action2 ; Break;
……………. ; Case Val2 :action2 ;
Valn :actionn ; Break ;
Autre :actionn+1 ……………. ;
Case Valn :actionn
break ; ;
default : actionn+1
}
Repeter Do{
Actions Actions ;
Jusqu’à condition }while(condition)
Tant que condtion faire While(condtion)
Action ; {
Ftq ; Action ;
}
Pour i de val1 à valn faire For( i=val1;i<=valn; i++)
Action ; {
Fpour ; Action ;
}
6.3.BIBLIOGRAPHIE
1) ALAIN CARDON, CHRISTIAN CHARAS. – Introduction à la
programmation
2) Moussa LÔ et Fatou KAMARA. – Algorithmique et Programmation.
USB Saint Louis
3) Kéba DIOP. – Algorithmique et structures de données. Tome1 et
Tome2, Press de l’université de l’UNIS 4) Microsoft Encarta 2009
51

Support ALGORITHME2023-2024

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

Support ALGORITHME2023-2024

Transféré par

Droits d'auteur :

Formats disponibles

Université de Labé Support de Cours d’Algorithmique1- Par M.K.

DELAMOU édition 2023 Tel 622088864

Table des matières

Chapitre 1 INTRODUCTION A LA PROGRAMMATION

- Programmeur= Toute personne capable d’écrire des programmes

Décrire les étapes à suivre Tradition en langage compréhensible

La programmation est constituée de deux phases :

• La résolution du problème, c'est-à-dire la détermination d’un algorithme réalisant le

1.5. Double problématique de l’algorithmique

Chapitre 2 LES DECLARATIONS

2.1. Les Types de données

Une troisième catégorie sera nécessaire :

2.1.3. Les types de bases ou prédéfinis

2.1.3.2. Les numériques (les entiers et les réels)

En informatique, pour les représenter, on est limité par la capacité de la machine.

Objectif : Il s’agit de trouver une représentation interne des nombres

- Ne représenter qu’un sous-ensemble des entiers relatifs ; - Réaliser

Exemple : l’amplitude des nombres entiers relatifs représentés dépend de la taille de

Sur 2 octets : -215<=Z<=+215-1 -32 768<=Z<=+32767

2.1.3.3. Les Booléens

2.1.4. Etude détaillée des types de bases

2.1.4.1. Les Caractères

Notation du type Car

2.1.4.2. Les entiers

Notation du type Entier

Table de vérité des opérateurs logiques

Soient deux propositions P et Q ; nous avons les tables de vérités suivantes :

2.1.5. Les types construits

➢ Les fonctions de conversion

Fonctions Résultat Exemple

Chnum() : convertit une chaine en nombre ;

Numch() : convertit un nombre en chaine.

2.1.5.2. Le type énuméré

b) Exemple : type entier=-32768..32767

Lundi et mardi proviennent d’un type hôte (type semaine).

2.1.5.4.Le type composé ou structuré

- Un objet composé correspond à plusieurs emplacements

A tout objet est associée une valeur.

L’adresse est confondue avec le nom.

a) Nom : au niveau du programme, on préfère manipuler un nom plutôt qu’une adresse. Le

L’ensemble de ces étapes descriptives s’appelle la déclaration.

2.2.3. Les Variables

Exemple: Var 1age : entier ; Incorrecte

Règle N°2 : Le nom d’une variable ne doit pas contenir d’espace.

Exemple : Var pre nom: Chaine (20); Incorrecte

Chapitre 3 LES ENTREES SORTIES CONVERSATIONNELLES

3.1. Ordre de Sortie : l’instruction « Afficher »

a) Syntaxe : Afficher (<liste des données à afficher>)

Cette liste peut contenir :

- Affichage de message : Afficher (‘Aujourd’’hui’) ;

Exemple : Affichage (‘Votre age est : ‘, age) ;

d) Présentation des données numériques

Saisir(nom_var) ou lire(nom_var) ; Où nom_var doit être :

- Affectation : rangement d’une valeur dans une cellule mémoire

- Dynamique : la valeur est connue au moment de l’exécution

Chapitre 4 LES INSTRUCTIONS DE CALCUL ET D’AFFECTATION

4.1.1. Classification des opérateurs selon le nombre d’opérandes

On classe les opérateurs en deux catégories :

4.1.2. Négation des expressions à résultat booléen

Le tableau ci-dessous donne la négation des opérateurs de relation.

Une expression désigne :

- Une valeur affectée ou une constante,

b) Exemple de syntaxe incorrecte