objectif général : Acquérir les bases méthodologiques de la résolution d'un problème devant conduire à la réalisation d'un programme informatique. objectifs opérationnels : Connaître les étapes de résolution d’un problème. Stocker et traiter des données simples Communiquer avec l’algorithme. Contrôler le flux d’exécution des instructions. Traiter des données composites. Définir et utiliser des procédures et des fonctions.

1. Initiation à
l’algorithmique
M. Abdoulaye DIENG Juin 2014

2. Objectif général
Acquérir les bases méthodologiques de la
résolution d'un problème devant conduire à la
réalisation d'un programme informatique.
2

3. Objectifs opérationnels
• Connaître les étapes de résolution d’un
problème.
• Stocker et traiter des données simples
• Communiquer avec l’algorithme.
• Contrôler le flux d’exécution des instructions.
• Traiter des données composites.
• Définir et utiliser des procédures et des
fonctions.
3

4. Sommaire
1. Algorithme
2. Étapes de résolution d’un
problème
3. Notion d’identificateur
4. Notion de variable
5. Types simples
6. Notion de constante
7. Opérateurs
8. Affectation
9. Entrées/sorties
10. Structures de contrôle
11. Tableaux
12. Sous-programmes
13. Enregistrements
4

5. Algorithme
présentation
• L’algorithmique est la science qui étudie l’application des
algorithmes à l’informatique
• L’algorithme est une suite finie d’instructions que l’on applique
à un nombre fini de données pour résoudre un problème.
• En informatique, l’algorithme est écrit dans un langage proche
du langage humain appelé pseudo langage.
• L’algorithme n'est donc exécutable directement par aucune
machine, mais il a l'avantage d'être traduit facilement dans
tous les langages de programmation.
5
problème
algorithme
réflexion
programme
traduction

6. Algorithme
exemple : "préparation du thé à la sénégalaise"
• Les ingrédients : thé, sucre, eau.
• Le résultat : verres de thé.
• Le matériel : théière, verres à thé, plateau, réchaud, allume-gaz.
• Les actions à réaliser
1. Mettre de l’eau dans la théière
2. Mettre du thé dans la théière
3. Allumer le réchaud à l’aide de l’allume-gaz
4. Poser la théière sur le réchaud
5. Attendre jusqu’à l’ébullition
6. Eteindre le réchaud
7. Poser la théière sur le plateau
8. Mettre du sucre dans la théière
9. Faire de la mousse de thé avec les verres
10. Si le thé est très refroidi alors
10.1. Rallumer le réchaud
10.2. Réchauffer le thé
10.3. Éteindre le réchaud
11. Remplir les verres de thé
12. Servir le thé
6
Raffinement de la 9ème instruction
9.1. Poser les verres sur le plateau
9.2. Remplir un verre de thé au 3/4
9.3. Transvaser ce thé d’un verre à un autre
jusqu’à l’obtention de la mousse dans
tous les verres

7. Algorithme
caractéristiques
Un algorithme doit être :
• lisible : compréhensible (même par un non-informaticien) ;
• de haut niveau : pouvoir être traduit en n’importe quel langage de
programmation ;
• précis : aucun élément de l’algorithme ne doit porter à confusion ;
• concis : un algorithme ne doit pas dépasser une page ; si c’est le
cas, il faut décomposer le problème en plusieurs sous-problèmes ;
• structuré : un algorithme doit être composé de différentes parties
facilement identifiables.
7

8. Algorithme
structure(1/2)
 Un algorithme est composé d’une entête et d’un corps
 L'entête spécifie :
 le nom de l'algorithme annoncé par le mot « Programme »
 la définition de types annoncée par le mot « Type » ;
 la déclaration de constantes, annoncée par le mot « Constante » ;
 la déclaration de variables, annoncée par le mot « Variable » ;
 les définitions de sous programmes.
 le corps est composé :
 du mot-clé « Début » ;
 d'une suite d'instructions indentées ;
 du mot-clé « Fin ».
 Les commentaires sont entre (* et *).
8

9. Algorithme
structure (2/2)
Programme nom du programme
Type
(* Définition de types *)
Constante
(* Déclaration de constantes *)
Variable
(* Déclaration de variables *)
Définition de sous-programmes
Début
(* instructions du programme *)
Entête du programme
Corps du programme
Fin 9

10. Résolution d’un problème
cinq étapes
• Étape 0 : compréhension de l’énoncé du problème.
• Étape 1 : décomposition du problème (complexe) en sous-problèmes.
• Étape 2 : spécification de chaque sous-problème ou du
problème (simple).
• Étape 3 : algorithme logique de chaque sous-problème ou du
problème (simple).
• Étape 4 : algorithme de programmation du problème.
10

11. Résolution d’un problème
compréhension de l'énoncé
• Formulation ou reformulation du texte qui décrit le problème
à résoudre.
• Doit permettre la compréhension du problème par soi-même
ambiguïté, complétude, cohérence ?
11

12. Résolution d’un problème
décomposition
• Cette étape est basée sur la stratégie « diviser pour régner ».
• Commencer par décomposer le problème initial en sous-problèmes,
puis chaque sous-problème en de nouveaux sous-problèmes
et ainsi de suite jusqu’aux problèmes que l’on peut
résoudre à partir d’opérations primitives.
• Question à se poser :
quelles sont les grandes étapes à réaliser ?
• NB : si le problème est simple, l’étape de la décomposition n’est
pas nécessaire.
12

13. Résolution d’un problème
spécification
Pour chaque problème simple, déterminer :
1. les données d’entrée : venant de l’extérieur et étant
nécessaires au problème ;
2. les données de sortie ou résultat attendu du problème par
l’extérieur ;
3. le traitement à faire :
formules, équations, fonctions, constantes et autres outils
nécessaires à l’obtention des données de sortie ou du résultat
attendu à partir des données d’entrée.
13

14. Résolution d’un problème
algorithme logique
• Constitué uniquement des instructions (en pseudo-langage)
indispensables au traitement : pas d’entête ni instruction de
présentation
• Prévoir éventuellement un lexique des variables et constantes
utilisées.
NB : avec des identificateurs explicites, le lexique est inutile.
14

15. Résolution d’un problème
algorithme de programmation
• Algorithme complet avec entête et instructions de
présentation
• Algorithme qu’on pourra traduire en langage de
programmation
15

16. Notion d’identificateur
 Nom donné aux diverses composantes (types, constantes,
variables et sous-programmes) d'un programme.
 Formé de lettres alphabétiques et de chiffres ainsi que du
caractère _ (espace souligné).
 Le 1er caractère ne doit pas être un chiffre.
 L’identificateur doit être suffisamment explicite.
• Les variables et les sous-programmes commencent toujours
par une minuscule.
• Les types commencent toujours par une majuscule.
• Les constantes ne sont composées que de majuscules.
 Lorsque l’identifiant contient plusieurs mots, on articule ces
mots avec des majuscules ou avec le caractère _.
 Exemples : note1, fin_de_fichier, finDeFichier, TVA, PI
 Contre-exemples : 4eme, x#y, note-1, note 1.
16

17. Notion de variable
• Une variable permet de désigner un emplacement mémoire et possède :
• une valeur ou contenu « provisoire » ;
• un type décrivant un ensemble de valeurs et un ensemble
d'opérateurs sur ces valeurs ;
• un identificateur ou nom permettant l’accès au contenu.
• NB : toute variable utilisée dans le corps du programme doit d’abord être
déclarée dans l’entête.
• Déclaration d’une ou de plusieurs variables :
Variable identificateur1[,identificateur2, …] : Type
17

18. Type de données
 Un type de données caractérise l’ensemble des :
 valeurs que peut prendre une variable ;
 actions que l’on peut effectuer sur une variable.
 Une fois qu’un type de données est associé à une variable,
 le contenu de cette variable doit être du même type ;
 cette variable ne peut plus changer de type.
 Il y a deux grandes catégories de type :
 les types simples ;
 les types complexes ou composites.
18

19. Types simples
numériques
 Naturel : entiers non signés (sous-ensemble de IN)
 Entier : positifs et négatifs (sous-ensemble de Z)
 Réel : sous-ensemble de IR
exemples : 0.1, -1.2 (attention utilisation du . à la place de la ,)
 Exemples de déclaration de variables numériques
Variable
age : Naturel
temperature : Entier
taille, poids : Réel
19

20. Types simples
booléen, caractère et chaîne de caractères
 Booléen : les variables ne prennent que les valeurs VRAI ou FAUX
 Caractère : lettre, chiffre ou symbole (visible ou non) entouré par de
simples quotes (apostrophes)
 Chaîne de caractères : suite de caractères entourée de doubles
quotes (guillemets).
 Exemples
Variable masculin : booléen
initiale : caractère
nom : chaîne de caractères
20

21. Notion de constante
 Une constante représente une donnée qui ne change jamais durant
tout le programme
 Une constante a un type et une valeur
• Syntaxe de la déclaration d’une constante :
constante IDENTIFICATEUR = valeur
 Lorsque l’identifiant d’une constante contient plusieurs mots, on les
articule avec le caractère _.
21

22. Les opérateurs
arithmétiques
• Six opérateurs arithmétiques : addition (+), soustraction (-),
multiplication (x), division (/), division entière (DIV), reste de la
division entière ou modulo (MOD).
• Leurs opérandes peuvent être des entiers ou des réels hormis ceux
des deux derniers qui agissent uniquement sur des entiers.
• Lorsque les types des deux opérandes sont différents, il y a
conversion implicite dans le type le plus fort.
naturel < entier < réel
22

23. Les opérateurs
relationnels
• Six opérateurs relationnels
– < inférieur à
– ≤ inférieur ou égal à
– > supérieur à
– ≥ supérieur ou égal à
– = égal à
– ≠ différent de
• Le résultat d’une comparaison est un booléen
23

24. Les opérateurs
logiques
• Trois opérateurs logiques : ET, OU, NON
• Tables de vérité
A V V F F
B V F F V
A ET B V F F F
A OU B V V F V
NON A F F V V
Vraie si tous les opérandes sont vrais
Vraie si au moins l’un des opérandes est vrai
• L’évaluation est faite de gauche à droite et le processus est interrompu
dès que le résultat final est déterminé.
• Lois de Morgan
NON (A ET B)  (NON A) OU (NON B)
NON (A OU B)  (NON A) ET (NON B) 24

25. Les opérateurs
priorité et associativité
• Lorsque plusieurs opérateurs sont utilisés dans la même instruction,
certains sont prioritaires par rapport à d'autres.
Exemple : -2 + 4 x 3 = 10
• Les parenthèses permettent de modifier l’ordre de priorité par défaut
Exemple : -(2 + 4) x 3 = -18
• Si les opérateurs ont la même priorité, l'associativité détermine leur
ordre d'exécution.
Exemple : -2 + 1 - 8 / 2 x 3 = -13
25

26. Les opérateurs
Associativité et priorités par ordre décroissant
26
Catégorie Opérateurs Associativité
Référence ( ) [ ] . -> GD
Unaire +, -, NON DG
Arithmétique *, /, DIV, MOD GD
Arithmétique +, - GD
Relationnel <, ≤, >, ≥ GD
Relationnel =, ≠ GD
Logique ET GD
Logique OU GD
+
p
r
i
o
r
i
t
a
i
r
e
-

27. L’affectation
• Avec le symbole ←, l’affectation a pour principal but d’attribuer une
valeur à une variable
• Sa syntaxe est :
IdentificateurDeLaVariable ← Valeur (ou expression)
• La signification de l’utilisation d’un identificateur de variable diffère
suivant sa position :
– à gauche du symbole d’affectation, l’identifiant nous permet de
modifier la valeur de la variable
– à droite du symbole d’affectation, l’identifiant nous permet
d’obtenir la valeur de la variable
27
tp1

28. Les entrées/sorties
• Un algorithme peut avoir des interactions avec l'utilisateur.
 L’outil ecrire() permet d’afficher du texte ou des valeurs.
 Syntaxe : ecrire("à écrire telle quelle", à_evaluer)
 L’outil lire() permet d’enregistrer, dans une variable, une donnée
saisie par l'utilisateur.
 Syntaxe : lire(nomVar1 [,nomVar2, …])
• Exemple :
ecrire("Quel est votre age ?")
lire(age)
ecrire("Vous avez ",age," ans")
28
Tp2&3

29. Structures de contrôle
présentation
 En programmation procédurale le processeur exécute les instructions
d’une manière séquentielle.
 Tant qu'une instruction n'est pas terminée, il attend avant de continuer.
Par exemple, une instruction de lecture va attendre que l'utilisateur rentre
une valeur avant de continuer.
 Parfois, il est nécessaire que le processeur n'exécute pas toutes les
instructions, ou encore qu'il recommence plusieurs fois les mêmes
instructions : c'est le rôle des structures de contrôle.
 Il existe deux grands types de structures de contrôle :
 les structures conditionnelles ;
 les structures répétitives (ou itératives) ou boucles.
29

30. Structures de contrôle
structure conditionnelle stricte
 Cette structure est utilisée si on veut exécuter un traitement (instruction
simple ou composée) seulement si une condition est vraie et ne rien
faire si la condition est fausse.
 Sa syntaxe :
Si (condition) Alors
traitement
FinSi
 Que le traitement soit exécuté ou non, le programme continue
normalement son exécution après l’instruction FinSi.
30
Tp4

31. Structures de contrôle
structure conditionnelle alternative
• Elle permet d'exécuter deux traitements différents en fonction de la
valeur booléenne d’une condition.
• Sa syntaxe :
Si (condition) alors
traitement_1
Sinon
traitement_2
FinSi
• Après l’exécution du traitement 1 ou du traitement 2, le programme
continue normalement son exécution juste après l’instruction Finsi.
31
Tp5

32. Structures de contrôle
structure conditionnelle alternative multiple
• La structure conditionnelle alternative multiple permet d'exécuter
plusieurs traitements différents en fonction de valeurs booléennes de
plusieurs conditions.
• Sa syntaxe :
Si (condition_1) Alors
traitement_1
Sinon si (condition_2) Alors
traitement_2
…
Sinon (*Si aucune des n-1 conditions n’est vraie*)
traitement_n
FinSi
32
Tp6

33. Structures de contrôle
structure conditionnelle de choix
 La structure conditionnelle de choix permet de choisir le traitement à
effectuer en fonction de la valeur d'une variable ou d'une expression.
 Sa syntaxe :
Selon (expression) Faire
valeur 1 de l'expression : traitement 1
valeur 2 de l'expression : traitement 2
…
[Sinon : traitement par défaut]
FinSelon
 L’expression ou la variable est de type entier ou caractère.
• Dès qu’une valeur est vérifiée, le traitement associé est exécuté puis le
programme continue normalement son exécution juste après
l’instruction FinSelon sans envisager les cas suivants.
33
Tp7

34. Structures de contrôle
structure itérative « Tant que … Faire »
• La boucle Tant que … Faire permet de répéter un traitement tant
qu'une expression conditionnelle est vraie.
• Sa syntaxe :
Tant que (condition) faire
traitement
finTantQue
• La condition est testée avant la première exécution du traitement
• Ce traitement peut d’ailleurs ne jamais s’exécuter.
• Il est nécessaire d’initialiser la condition pour le premier passage.
• Il faut s’assurer que le traitement fait évoluer la condition pour que la
terminaison de la boucle soit assurée.
• Lorsque la condition devient fausse le programme continue
normalement son exécution après l’instruction qui suit le FinTantQue.
34
Tp8

35. Structures de contrôle
structure itérative « Faire … Tant que »
• La boucle Faire … Tant que permet de répéter un traitement tant
qu'une expression conditionnelle est vraie.
• Sa syntaxe
Faire
traitement
Tant que (condition)
• Le traitement s’exécute au moins une fois et l’initialisation de la
condition pourra se faire à l’intérieur de la boucle
• Lorsque la condition devient fausse, la boucle se termine et le
programme continue normalement son exécution après l’instruction
Tant que (condition).
35
Tp9

36. Structures de contrôle
structure itérative « Pour »
 La boucle Pour permet de répéter un traitement un nombre connu de
fois.
 Sa syntaxe
Pour var_compteur ← val_initiale à val_finale [pas de p] faire
traitement
FinPour
 La variable compteur est de type entier ; elle est initialisée à la valeur
initiale et elle augmente (implicitement) de p (peut être négatif) à chaque
répétition du traitement.
 Par défaut, l’incrément p est de 1.
 Lorsque la variable compteur vaut la valeur finale, le traitement est
exécuté une dernière fois puis le programme sort de la boucle. 36
Tp10

37. Les tableaux
présentation
• Un tableau permet de désigner sous un seul nom un regroupement de
données de même type.
• Les données sont mémorisées dans des cases contigües et chaque
donnée est repérée par un indice (entier naturel)
• Déclaration d’un tableau à une dimension :
nom_tab : tableau [DIM] de type_des_données
• Notation d’une donnée ou variable indicée : nom_tab[indice]
• L’indice varie de 0 à DIM – 1.
• Exemple : voyelles : tableau [6] de caractères
Dans ce cas la donnée 'e' est notée par voyelles[1]
37
données 'a' 'e' 'i' 'o' 'u' 'y'
indices 0 1 2 3 4 5
Tp11

38. Les tableaux
tableaux à deux dimensions
• Un tableau à deux dimensions est un tableau (à une dimension) qui
contient des tableaux (à une dimension).
• Chaque donnée est repérée par deux indices (entiers naturels)
• Déclaration :
nom_tab : tableau[DIM1][DIM2] de type_des_données
• Notation d’une donnée :
nom_tab[indice1][indice2]
avec 0 ≤ indice1 < DIM1 et 0 ≤ indice2 < DIM2
• Exemples :
voyelles : tableau[2][3] de caractères
'a' 'e' 'i'
0 1 2
'o' 'u' 'y'
0 1 2
0 1
la donnée 'e' est notée par voyelles[0][1] 38

39. Les tableaux
tableaux à deux dimensions (suite et fin)
• Un tableau à deux dimensions est représenté en mémoire comme un
tableau à une seule dimension par concaténation des tableaux stockés.
• Les données sont rangées suivant l’ordre obtenu en faisant varier le
dernier indice en premier.
39
'a' 'e' 'i'
0,0 0,1 0,2
'o' 'u' 'y'
1,0 1,1 1,2
Tp12

40. Les sous-programmes
présentation
• Les sous-programmes permettent de
– décomposer un problème en sous-problèmes ;
– découper le programme pour facilité la lisibilité et le débogage ;
– réutiliser du code qui revient souvent.
• Comme le programme principal, tout sous-programme possède un
nom, des variables, des instructions, un début et une fin.
• Mais un sous-programme n’est exécuté que lorsqu’il est appelé par un
autre (sous-)programme.
• Il existe deux types de sous-programmes :
 la procédure faisant une certaine tâche ;
 la fonction renvoyant en plus une valeur résultat.
• L'appel d'une procédure constitue une instruction en lui-même.
• L'appel d'une fonction est remplacé à l'exécution par la valeur
retournée par celle-ci. Il doit forcément se trouver dans un calcul, une
affectation, un affichage, un test, etc. 40

41. Les sous-programmes
visibilité des variables
• Une variable déclarée dans un sous-programme est dite locale et n’est
utilisable que par ce sous-programme.
• Une variable globale est déclarée à l’extérieur des sous-programmes et
est visible partout dans le programme.
• Le même nom de variable peut désigner plusieurs variables locales
différentes.
• En revanche, une variable globale n'existe qu'en un seul exemplaire
pour tous les sous-programmes.
• Lorsque le nom d'une variable locale est identique à une variable
globale, la variable globale est localement masquée; dans ce sous-programme
la variable globale devient inaccessible.
41

42. Les sous-programmes
les paramètres
• Rappelons qu’un sous-programme n’est exécuté que lorsqu’il est
appelé par un autre (sous-)programme.
• La communication entre sous-programme appelée et (sous-
)programme appelant se fait par l'intermédiaire de variables
particulières et locales au sous-programme appelé que l’on nomme
paramètres formels.
• Lors de l’appel, tout paramètre formel est associé à une variable ou
constante de même type nommée paramètre effectif du
(sous-)programme appelant.
• Il existe trois types d'association ou de passage de paramètre :
– le passage de paramètres en entrée ;
– le passage de paramètres en sortie ;
– le passage de paramètres en entrée/sortie. 42

43. Les sous-programmes
passage de paramètres (schéma comparatif)
Paramètre en entrée
43
Paramètre en sortie
Paramètre en entrée et sortie
Clé USB
CD vierge
CDROM
Sous programme

44. Les sous-programmes
passage de paramètres en entrée
• Les instructions du sous-programme appelé ne peuvent pas modifier le
paramètre effectif.
• En fait c'est uniquement la valeur du paramètre effectif qui est copiée
dans le paramètre formel
• C'est le seul passage de paramètre qui admet l'utilisation d'une
constante comme paramètre effectif.
• Exemple :
le sous-programme écrire() qui permet d'afficher des informations
admet des paramètres en entrée.
44

45. Les sous-programmes
passage de paramètres en sortie
• Les instructions du sous-programme appelé affectent obligatoirement
une valeur au paramètre formel (valeur qui est donc aussi affectée au
paramètre effectif associé)
• Eviter d’utiliser des constantes comme paramètre effectif pour ce type
de passage de paramètres.
• La valeur que pouvait posséder le paramètre effectif n'est pas utilisée
par le sous-programme appelé.
• Exemple :
Le sous-programme lire() qui permet de mettre dans des variables des
valeurs entrés par l'utilisateur admet des paramètres en sortie
45

46. Les sous-programmes
passage de paramètres en entrée/sortie
• Passage de paramètre qui combine les deux précédents
• A utiliser lorsque le sous-programme appelée doit utiliser puis modifier
la valeur du paramètre effectif.
• Comme pour le passage de paramètre en sortie, on ne peut pas utiliser
une constante comme paramètre effectif
• Exemple :
Le sous-programme échanger() qui permet d'échanger les valeurs de
deux variables admet des paramètres en entrée/sortie
46

47. Les sous-programmes
les fonctions
• Une fonction est un sous-programme admettant des paramètres et
retournant un seul résultat (comme en Maths y=f(a,b,c,…)).
• Une fonction possède un type qui est celui de la valeur retournée
• Le passage de paramètres est uniquement en entrée
• Les paramètres effectifs peuvent être des variables, des constantes mais
aussi des résultats de fonctions
• Syntaxe de la définition d’une fonction:
Fonction nomFonction( nomParam1:typeParam1[,…] ):typeRslt
Variable
Déclaration des éventuelles variables locales
Début
instruction(s)
retourne rslt
FinFonction
47
Tp13

48. Les sous-programmes
les procédures
• Une procédure est un sous-programme qui ne retourne aucun résultat
• Par contre elle peut admettre des paramètres avec des passages :
– en entrée, préfixés par E (ou →)
– en sortie, préfixés par S (ou ←)
– en entrée/sortie, préfixés par E/S (ou ↔)
• Syntaxe de la définition d’une procédure :
Procédure nomProcedure([ modeDePassage nomParam1:typeParam1[,…] ])
Variable
Déclaration d’éventuelles variables locales
Début
instruction(s)
finProcédure
48
Tp14&15

49. Les enregistrements
présentation
• Un enregistrement est une structure de données dont les éléments
(ou champs) peuvent être de types différents.
• Il permet ainsi de regrouper des informations qui vont ensemble
sous un seul nom afin de les manipuler plus facilement.
• Syntaxe de la déclaration d’un enregistrement:
Variable nom_enregistrement : nom_type
• La déclaration du type structuré doit précéder celle de
l’enregistrement correspondant.
• Syntaxe de la déclaration d’un type structuré:
TYPE nom_type=structure
nom_champ1 : type_champ1
…
nom_champN : type_champN
finStructure
• Syntaxe de l’accès à un champ d’un enregistrement:
nom_enregistrement.nom_champ
• Le champs s’utilise comme une variable simple 49
Tp16