Algorithme et Programmation

Première Année

Carlos AGOSSOU
DOCTORANT EN INFORMATIQUE ET TELECOMS
 Algorithme et Programmation

Cours d’Algorithme et Programmation

Objectif :
 Apprendre les concepts de base de l'algorithmique et de la programmation
 Être capable de mettre en oeuvre ces concepts pour analyser des problèmes
simples et écrire les programmes correspondants
Points généraux :
 introduction à l’algorithmique et à la programmation
 Généralités sur l’algorithmique et les langages de programmation
 Notion de variable, affectation, lecture et écriture
 Instructions conditionnels et instructions itératives
 Les Tableaux, les fonctions et procédures, la récursivité
 Introduction à la complexité des algorithmes
 Données structurées
Initiation au Langage C (Travaux pratiques)

1
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

Table des matières

1.1. Instruction conditionnelle ............................................................................... 3
1.2. SELECTION CHOIX MULTIPLES « SELON » ............................................ 5
1.3. Répétition d’un traitement ............................................................................. 7
1.3.1. La boucle itérative « POUR » ....................................................................... 7
1.3.2. Répétition d’un traitement à nombre itérations inconnu « Tant que …
faire » 9
1.3.3. Comparaison boucles « Pour » et « Tant que » .......................................... 10
1.3.4. Boucle « Répéter …tant que » OU « Répéter …jusqu’à » .......................... 11
1.3.5. Comparaison «Répéter» et «Tant que» ...................................................... 12
1.3.6. Choix d'un type de boucle .......................................................................... 12
1.4. Applications ................................................................................................... 13

2
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

Chapitre 2 : Des structures importantes

1.1. Instruction conditionnelle

Définition : La résolution des certains problèmes nécessite la mise en place d’un
test pour savoir si l’on doit effectuer une tâche.
Si la condition est remplie alors on effectue la tâche, sinon on effectue
(éventuellement) une autre tâche. Dans un algorithme, on code la structure du
« Si... Alors… Sinon… FinSi » sous la forme suivante :
Si condition Alors
Tâche 1
Tâche 2
...
Sinon
Tâche 1bis
Tâche 2bis
...
Fin Si

Remarques :
1. Il est important de respecter l’indentation au début de chaque ligne, car il
permet une meilleure lisibilité de l’algorithme.
2. Si l’expression logique (la condition) prend la valeur vrai, le premier bloc
d’instructions est exécuté;
3. Si elle prend la valeur faux, le second bloc est exécuté (s’il est présent, sinon,
rien).
4. Le « Sinon » n’est pas obligatoire. S’il n’est pas présent, aucune tâche ne sera
effectuée si la condition n’est pas remplie.
Exemples :
1. L’algorithme 2 permet de déterminer si un triangle ABC est rectangle en C.
2. L’algorithme 3 est un exemple d’algorithme calculant l’image d’un réel x par
la fonction f : x → (x+1)/(x−1) en respectant son ensemble de définition.

3
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

Algorithme 2 Triangle rectangle en C

/* Cet algorithme permet de déterminer si un triangle ABC est rectangle en C */

Variables AB, AC, AB, x, y : Réels

Début
Afficher (‘’Entrer la valeur de AB‘’)
Saisir (AB)
Afficher (‘’Entrer la valeur de AC‘’)
Saisir (AC)
Afficher (‘’Entrer la valeur de BC‘’)
Saisir (BC)

/*Traitement */
x ← AB^2
y ← (AC^2) + (BC^2)
Si x == y Alors
Afficher (‘’Le triangle ABC est rectangle en C‘’)
Sinon
Afficher (‘’Le triangle ABC n’est pas rectangle en C‘’)
Fin Si
Fin

Algorithme 3 Image par une fonction

/* Cet algorithme calcule l’image d’un réel x par la fonction f : x → (x+1)/(x−1) en respectant son
ensemble de définition */

Variables x, y : Réels

Début
Saisir(x)
/*Traitement */
Si x != 1 Alors
y ← (x + 1) / (x − 1)
Afficher(y)
Sinon
Afficher (‘’La valeur choisie n’est pas dans l’ensemble de définition‘’)
Fin Si
Fin

Remarque : Les tests peuvent avoir un degré quelconque d'imbrications

Si condition1 alors
Si condition2 alors
instructionsA
Sinon
instructionsB
Fin Si
Sinon
Si condition3 alors
instructionsC
Fin Si
Fin Si

4
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

Exemple :
Algorithme DeterminerSigneDuNombre
/* Cet algorithme permet de déterminer le signe d’un nombre saisi par l’utilisateur */
Variable n : entier
Début
Afficher ("entrez un nombre : ")
Saisir (n)
Si n < 0 alors
Afficher ("Ce nombre est négatif")
Sinon
Si n == 0 alors
Afficher ("Ce nombre est nul")
Sinon
Afficher ("Ce nombre est positif")
Fin Si
Fin Si
Fin

Conseil : utiliser les tests imbriqués pour limiter le nombre de tests et placer
d'abord les conditions les plus probables

1.2. SELECTION CHOIX MULTIPLES « SELON »

Selon <identificateur>
(liste de) valeur(s) : instructions
(liste de) valeur(s) : instructions
…
[autres: instructions]
Fin Selon

Remarques : S’il y a plus de deux choix possibles, l’instruction « Selon » permet

une facilité d’écriture
Exemples :

5
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

Selon abreviation
"M" : afficher( " Monsieur " )
"Mme" :afficher( " Madame " )
"Mlle" : afficher( " Mademoiselle " )
autres : afficher( " Monsieur, Madame " )
Fin Selon

/* Équivalent avec instruction Conditionnelle */

Si abreviation == "M" Alors

afficher( "Monsieur" )
Sinon
Si abreviation == "Mlle" Alors
afficher("Mademoiselle")
Sinon
Si abreviation == "Mme" Alors
afficher( "Madame" )
Sinon
afficher( "Monsieur, Madame " )
Fin Si
Fin Si
Fin Si

Selon abreviation
"M" : afficher( " Monsieur " )
"Mme" :afficher( " Madame " )
"Mlle" : afficher( " Mademoiselle " )
autres : afficher( " Monsieur, Madame " )
Fin Selon

/* Équivalent avec instruction Conditionnelle */

Si abreviation = "M" Alors

afficher( "Monsieur" )
Fin Si
Si abreviation = "Mlle" Alors
afficher( "Madame" )
Fin Si
Si abreviation = "Mme" Alors
afficher("Mademoiselle")
Sinon
afficher( "Monsieur, Madame " )
Fin Si

6
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

1.3. Répétition d’un traitement

Les boucles servent à répéter l'exécution d'un groupe d'instructions un certain
nombre de fois
On distingue trois sortes de boucles en langages de programmation :
 Les boucles Tant que… faire : on y répète des instructions tant qu'une
certaine condition est réalisée
 Les boucles Répéter… jusqu'à : on y répète des instructions jusqu'à ce
qu'une certaine condition soit réalisée
 Les boucles Pour ou avec compteur : on y répète des instructions en faisant
évoluer un compteur (variable particulière) entre une valeur initiale et une
valeur finale

1.3.1.La boucle itérative « POUR »

Définition : Lorsque l’on doit répéter un nombre de fois connu à l’avance la même
tâche, on utilise une boucle itérative de la forme « Pour.. allant de... à ».
Dans un algorithme, cette structure est codée de la façon suivante :
Pour variable allant de valeur_depart à valeur_fin par pas de valeur_pas faire
tâche 1
tâche 2
...
Fin pour

Remarques
 La variable utilisée dans la boucle est appelée compteur. À chaque passage
dans la boucle, sa valeur est automatiquement augmentée de valeur_pas.
 valeur_pas peut ne pas être mentionné, car par défaut sa valeur est égale à
1. Dans ce cas, le nombre d'itérations est égal à valeur_fin - valeur_depart +
1
 L’instruction Pour:
o initialise une variable de boucle (le compteur)
o incrémente cette variable de la valeur de valeur_pas
o vérifie que cette variable ne dépasse pas la borne supérieure

7
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

 valeur_fin et valeur_depart peuvent être des valeurs, des variables définies

avant le début de la boucle ou des expressions de même type que compteur
 Attention :
o le traitement ne doit pas modifier la variable de boucle

Exemples :
1. L’algorithme 5 affiche la table de multiplication (de 0 à 10) d’un nombre
entier donné.
Algorithme 5 Table de multiplication
Variables n, m, i : Entiers
Début
Afficher (‘’Entrer un nombre :’’)
Saisir(n)
/* Traitement */
Pour i allant de 0 à 10 faire
m←n×i
Afficher( n , " x ", i , " = ", m)
Fin Pour
Fin

2. L’algorithme 6 affiche la somme de tous les entiers jusqu’à un entier n saisi.

Algorithme 6 Calcul d’une somme d’entiers
Variables S, i, n : Entiers
Début
Afficher (‘’Entrer un nombre :’’)
Saisir(n)
S←0
/* Traitement */
Pour i allant de 1 à n faire
S←S+i
Fin Pour
Afficher( S )
Fin

8
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

1.3.2.Répétition d’un traitement pour un nombre itérations inconnu

« Tant que … faire »

Remarque :
La condition (dite condition de contrôle de la boucle) est évaluée avant chaque
itération
 Si la condition est vraie, on exécute les instructions (corps de la boucle), puis,
on retourne tester la condition. Si elle est encore vraie, on répète l'exécution,
…
 Si la condition est fausse, on sort de la boucle et on exécute l'instruction qui
est après FinTantQue
 Il est possible que les instructions à répéter ne soient jamais exécutées
 Le nombre d'itérations dans une boucle TantQue n'est pas connu au moment
d'entrée dans la boucle. Il dépend de l'évolution de la valeur de la condition
 Une des instructions du corps de la boucle doit absolument changer la valeur
de la condition de vrai à faux (après un certain nombre d'itérations), sinon
le programme va tourner indéfiniment : Attention aux boucles infinies
Exemple de boucle infinie :
/* A éviter */ /* Correction */
i←1 i←1
TantQue i > 0 Faire TantQue i <100 Faire
i ← i+1 i ← i+1
FinTantQue FinTantQue

Exemple:
Un algorithme qui détermine le premier nombre entier N tel que la somme de 1 à
N dépasse strictement 100

9
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

/* version 1 */ /* version 2 : attention à l'ordre des instructions

et aux valeurs initiales */
Variables som, i : Entier Variables som, i : Entier

Debut Debut
i←0 i←1
som← 0 som ← 0
TantQue (som <=100) Faire TantQue (som <=100) Faire
i ← i+1 som ← som + i
som ← som+i i ← i+1
FinTantQue FinTantQue
Afficher (" La valeur cherchée est N= ", i) Afficher (" La valeur cherchée est N= ", i-1)
Fin Fin

1.3.3.Comparaison boucles « Pour » et « Tant que »

Équivaut à

Pour cpt allant de 1 à nbVal faire cpt ← 0

afficher("Donnez une valeur :") Tant que cpt <nbVal faire
saisir(valeur) afficher("Donnez une valeur :")
/* cumul des valeurs */ saisir(valeur)
totalValeurs ← totalValeurs+ valeur /* cumul des valeurs */
Fin Pour totalValeurs←totalValeurs+ valeur
/* compte le nombre de valeurs traitées */
cpt ← cpt + 1
FinTantQue

 Implicitement, l’instruction Pour:

o initialise un compteur
o incrémente le compteur à chaque pas
o vérifie que le compteur ne dépasse pas la borne supérieure
 Explicitement, l’instruction Tant que doit :
o initialiser un compteur {amorçage}
o incrémenter le compteur à chaque pas {relance}
o vérifier que le compteur ne dépasse pas la borne supérieure {test de
boucle}
QUAND CHOISIR « POUR » OU « TANT QUE » ?
 Nombre d’itération connu à l’avance : POUR
o Parcours de tableaux
o Test sur un nombre donné de valeurs
 Boucle s’arrête sur événement particulier : TANT QUE
o Itération avec arrêt décidé par saisie utilisateur

10
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

1.3.4.Boucle « Répéter …tant que » OU « Répéter …jusqu’à »

Répéter
(ré)affectation de la (des) variable(s) de condition
traitement
Tant que <expression logique (vraie)>

ou
Répéter
instructions
Jusqu'à condition vraie

Remarques
 Condition est évaluée après chaque itération
 les instructions entre Répéter et jusqu’à sont exécutées au moins une fois
et leur exécution est répétée jusqu’à ce que la condition soit vraie (tant
qu'elle est fausse)
Exemple
Un algorithme qui détermine le premier nombre entier N tel que la somme de 1 à
N dépasse strictement 100 (version avec répéter jusqu'à)
Variables som, i : Entier
Debut
som ← 0
i←0
Répéter
i ← i+1
som ← som+i
Jusqu'à ( som > 100)
Afficher (" La valeur cherchée est N= ", i)
Fin

11
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

1.3.5.Comparaison «Répéter» et «Tant que»

Équivaut à

Répéter Afficher("Donnez une valeur positive paire :")

Afficher("Donnez une valeur positive paire :") saisir(valeur)
Saisir(valeur) Tant que(valeur < 0 ou(valeur % 2) != 0) faire
tant que(valeur < 0 ou(valeur % 2) != 0) Afficher("Donnez une valeur positive paire:")
Saisir(valeur)
FinTantQue

 Boucle Tant que

o condition vérifiée avant chaque exécution du traitement
o le traitement peut donc ne pas être exécuté
o de plus : la condition porte surtout sur la saisie de nouvelles variables
(relance)
 Boucle Répéter … tant que
o condition vérifiée après chaque exécution du traitement =>le traitement
est exécuté au moins une fois
o de plus: la condition porte surtout sur le résultat du traitement
Remarque: La boucle Répéter est typique pour les saisies avec vérification
Dans les deux cas, la séquence d'instructions doit nécessairement faire évoluer la
condition, faute de quoi on obtient une boucle infinie.

1.3.6.Choix d'un type de boucle

 Si on peut déterminer le nombre d'itérations avant l'exécution de la boucle,
il est plus naturel d'utiliser la boucle Pour
 S'il n'est pas possible de connaître le nombre d'itérations avant l'exécution
de la boucle, on fera appel à l'une des boucles Tant que ou Répéter jusqu'à

 Pour le choix entre Tant que et Répéter jusqu'à :

o Si on doit tester la condition de contrôle avant de commencer les
instructions de la boucle, on utilisera Tant que
o Si la valeur de la condition de contrôle dépend d'une première
exécution des instructions de la boucle, on utilisera répéter jusqu'à

12
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms
 Algorithme et Programmation

1.4. Applications
Exercice 1
Écrire un algorithme qui permet de saisir une valeur entière et affiche son double
si cette donnée est inférieure à un seuil donné.

Exercice 2
Écrire un algorithme qui, après avoir saisi la note de l’étudiant, permet d’afficher :
 "Reçu avec mention Assez Bien " si une note est supérieure ou égale à 12,
 " Reçu mention Passable " si elle est supérieure à 10 et inférieure à 12, et
 "Insuffisant" dans tous les autres cas.

Exercice 3
Ecrire un algorithme qui fait la somme de « N » nombres réels saisis.

Exercice 4
Écrire un algorithme qui demande un nombre entier à l'utilisateur, puis qui teste
et affiche s'il est impair et multiple de 3.

Exercice 5
Ecrire un algorithme qui permet de calculer la somme des n premiers termes de la
« série harmonique », c’est-à-dire la somme :
1 + 1/2 + 1/3 + 1/4 + ..... + 1/n
La valeur de n sera lue en donnée.

13
Enseignant : Ing Carlos AGOSSOU, Docteur en Informatique et Télécoms