Cours Algo 1 2

Université Paris XI
iUT ORSAY I.U.T. d'Orsay

Département Informatique
Année scolaire 2003-2004
Algorithmique : Volume 1
• Introduction
• Instructions de base
• Logique propositionnelle
Cécile Balkanski, Nelly Bensimon, Gérard Ligozat

Pourquoi un cours d’ "Algo" ?
• Objectif : obtenir de la «machine» qu’elle effectue

un travail à notre place
• Problème : expliquer à la «machine» comment
elle doit s'y prendre
Mais... comment le lui dire ?

Comment le lui apprendre ?
Comment s'assurer qu'elle fait ce travail aussi
bien que nous ?
Mieux que nous?
Algorithmique 1 : Introduction 1
Objectif de cet enseignement
• résoudre des problèmes «comme» une

machine
• savoir expliciter son raisonnement
• savoir formaliser son raisonnement
• concevoir (et écrire) des algorithmes :
- séquence d’instructions qui décrit comment résoudre
un problème particulier
Thèmes abordés en «Algo»
• Apprentissage d’un langage

• Notions de base
- algorithmes de « base » pour problèmes élémentaires
• Structures de données
- des plus simples aux plus complexes
• Résolution de problèmes complexes
- algorithmes astucieux et efficaces
L'algorithmique, vous la pratiquez tous les
jours et depuis longtemps...
Briques de LEGO Camion de pompiers

suite de dessins
Meuble en kit Cuisine équipée
notice de montage
Cafetière Expresso
instructions
Laine Pull irlandais

modèle
Farine, oeufs, chocolat, etc.... Forêt noire

recette
De l'importance de l'algorithme
Informations Résultats
éparses mis en forme
Machine
Données Obtention
structurées de résultats
Traitement
Un algorithme, traduit dans un langage compréhensible par l’ordinateur

(ou langage de programmation, ici le C++), donne un programme, qui
peut ensuite être exécuté, pour effectuer le traitement souhaité.
• Savoir expliquer comment faire un travail sans
la moindre ambiguïté
- langage simple : des instructions (pas élémentaires)
- suite finie d'actions à entreprendre en respectant une
chronologie imposée
• L’écriture algorithmique : un travail de

programmation à visée «universelle»
un algorithme ne dépend pas
- du langage dans lequel il est implanté,
- ni de la machine qui exécutera le programme correspondant.
Les problèmes fondamentaux
en algorithmique
• Complexité
- En combien de temps un algorithme va -t-il atteindre le
résultat escompté?
- De quel espace a-t-il besoin?
• Calculabilité :
- Existe-t-il des tâches pour lesquelles il n'existe aucun
algorithme ?
- Etant donnée une tâche, peut-on dire s'il existe un
algorithme qui la résolve ?
• Correction
- Peut-on être sûr qu'un algorithme réponde au problème
pour lequel il a été conçu?
Les instructions de base
Algorithmique 1 : Instructions de 8
base
Un premier algorithme
Algorithme ElèveAuCarré
{Cet algorithme calcule le carré du nombre que lui fournit l'utilisateur}
variables unNombre, sonCarré: entiers {déclarations: réservation

d'espace-mémoire}
début
{préparation du traitement}
afficher("Quel nombre voulez-vous élever au carré?")
saisir(unNombre)
{traitement : calcul du carré}
sonCarré ← unNombre × unNombre
{présentation du résultat}
afficher("Le carré de ", unNombre)
afficher("c'est ", sonCarré)
fin
Algorithmique 1 : Instructions de base 9
Les trois étapes d’un algorithme
• Préparation du traitement
- données nécessaires à la résolution du problème
• Traitement
- résolution pas à pas, après décomposition en sous-
problèmes si nécessaire
• Edition des résultats
- impression à l’écran, dans un fichier, etc.

Déclarer une variable
variable <liste d’identificateurs> : type
• Fonction :
Instruction permettant de réserver de l’espace mémoire
pour stocker des données (dépend du type de ces
données : entiers, réels, caractères, etc.)
• Exemples :
variables val, unNombre : entiers
nom, prénom : chaînes de caractères

Saisir une donnée
saisir(<liste de noms de variables>)
• Fonction :
Instruction permettant de placer en mémoire les
informations fournies par l'utilisateur.
• Exemples:
saisir(unNombre)
saisir(nom, prénom)
saisir(val)
Afficher une donnée, un résultat
afficher(<liste de noms de variables, de
constantes ou d ’expressions>)
• Fonction :
Instruction permettant de visualiser les informations
placées en mémoire.
• Exemples:
afficher(unNombre, "est différent de 0")
afficher("La somme de", unNombre, "et" , val , "est",
unNombre + val)

Déclarer une constante
constante (<identificateur> : type) ← <expression>
• Fonction :
Instruction permettant de réserver de l’espace mémoire
pour stocker des données dont la valeur est fixée pour tout
l’algorithme
• Exemples :
constantes (MAX : entier) ← 100
(DOUBLEMAX : entier) ← MAX × 2
Saisies et affichages : exemples
Algorithme ParExemple
{Saisit un prix HT et affiche le prix TTC correspondant}
constantes (TVA : réel) ← 20.6
(Titre : chaîne) ← "Résultat"
variables prixHT, prixTTC : réels {déclarations}
début {préparation du traitement}

afficher("Donnez-moi le prix hors taxe :")
saisir(prixHT)
prixTTC ← prixHT * (1+TVA/100) {calcul du prix TTC}
afficher(Titre) {présentation du résultat}

afficher(prixHT, « euros H.T. devient ", prixTTC, « euros T.T.C.")
Fin
Affichage :
Affecter une valeur à une variable
<identificateur> ← <expression> ou
<constante> ou <identificateur>
• Fonction :
Instruction permettant d’attribuer à la variable identifiée
par l'élément placé à gauche du symbole ← la valeur
de l'élément placé à droite de ce symbole.
• Exemple:
nom ← "Venus"
val ← 50
val ← val × 2
Affectation : exemples
constante (SEUIL : réel) ← 13.25
variables valA, valB : réels
compteur : entier
mot , tom : chaînes
valA ← 0.56
valB ← valA tableau de simulation :
valA ← valA × (10.5 + SEUIL) valA valB comp- mot tom
compteur ← 1 teur
compteur ← compteur + 10
mot ← " Bonjour "
tom ← "Au revoir ! "

Affectation : exemples (suite)
afficher(mot)
afficher(" valA = ", valA)
afficher(" valB = ", valB)
afficher(" compteur =", compteur )
afficher(tom)
Affichage :

Simulation d'un algorithme
Algorithme CaFaitQuoi?
{Cet algorithme .........................................}
variables valA, valB : réels {déclarations}
début {préparation du traitement}

afficher("Donnez-moi deux valeurs :")
saisir (valA, valB)
afficher("Vous m'avez donné ", valA, " et ", valB)
{traitement mystère}
valA ← valB
valB ← valA {présentation du résultat}
afficher("Maintenant , mes données sont : ", valA, " et ", valB)
Fin
Affichage :
Ce qu’il fallait faire …
• Déclarer une variable supplémentaire

variables valA, valB, valTemp : entiers
• Utiliser cette variable pour stocker provisoirement

une des valeurs
saisir(valA, valB)
valTemp ← valA
valA ← valB
valB ← valTemp

Traitement à faire si …
Algorithme SimpleOuDouble
{Cet algorithme saisit une valeur entière et affiche son double si cette
donnée est inférieure à un seuil donné.)
constante (SEUIL : entier) ← 10
variable val : entier
début
afficher("Donnez-moi un entier : ") { saisie de la valeur entière}
saisir(val)
si val < SEUIL { comparaison avec le seuil}
alors afficher ("Voici son double :" , val × 2)
sinon afficher ("Voici la valeur inchangée :" , val)
fsi
fin

L’instruction conditionnelle
si <expression logique>
alors instructions
[sinon instructions]
fsi
Si l’expression logique (la condition) prend la valeur vrai,

le premier bloc d’instructions est exécuté; si elle prend la
valeur faux, le second bloc est exécuté (s’il est présent,
sinon, rien).
Une autre écriture
Algorithme SimpleOuDouble
{Cet algorithme saisit une valeur entière et affiche son double si cette
donnée est inférieure à un seuil donné.)
variable val : entier
début
afficher("Donnez-moi un entier : ") { saisie de la valeur entière}
saisir(val)
si val < SEUIL
alors val ← val × 2 {comparaison avec le seuil }
fsi
afficher("Voici la valeur finale : ", val)
fin

Quand la condition se complique :
les conditionnelles emboîtées
Problème : afficher "Reçu avec mention" si une note est
supérieure ou égale à 12, "Passable" si elle est supérieure à
10 et inférieure à 12, et "Insuffisant" dans tous les autres cas.
si note ≥ 12
alors afficher( "Reçu avec mention" )
sinon si note ≥ 10
alors afficher( "Passable" )
sinon afficher( "Insuffisant" )
fsi
fsi

La sélection sur choix multiples
selon <identificateur>
(liste de) valeur(s) : instructions
(liste de) valeur(s) : instructions
…
[autres : instructions]
S’il y a plus de deux choix possibles, l’instruction selon

permet une facilité d’écriture.

L’instruction selon : exemple
selon abréviation
"M" : afficher( " Monsieur " )
"Mme" : afficher( " Madame " )
"Mlle" : afficher( " Mademoiselle " )
autres : afficher( " Monsieur, Madame " )
Comparer : si abréviation = "M"

alors afficher( "Monsieur" )
sinon si abréviation = "Mme"
alors afficher("Madame")
sinon si abréviation = "Mlle"
alors afficher( "Mademoiselle" )
sinon afficher( "Monsieur,Madame " )
fsi
fsi
fsi
Quand il faut répéter un traitement ...
Algorithme FaitLeTotal
{Cet algorithme fait la somme des nbVal données qu'il saisit}
variables nbVal, cpt : entiers
valeur, totalValeurs : réels
début
{initialisation du traitement}
afficher("Combien de valeurs voulez-vous saisir ?")
saisir(nbVal)
{initialisation du total à 0 avant cumul}
totalValeurs ← 0
{traitement qui se répète nbVal fois}
pour cpt ← 1 à nbVal faire
afficher("Donnez une valeur :")
saisir(valeur)
totalValeurs ← totalValeurs + valeur {cumul}
fpour
{édition des résultats}
afficher("Le total des ", nbVal, "valeurs est " ,
fin Algorithmique 1 : Instructions de base 27
Simulation de la boucle pour
• Données : 3 3 -1 10
• Tableau de simulation :
• Affichage :

La boucle « pour »
pour <var> ← valInit à valfin [par <pas>] faire

traitement {suite d’instructions}
fpour
• Fonction:
répéter une suite d’instructions un certain nombre de fois

Les champs de la boucle pour
constante, variable,
ou expression arithmétique
pour <variable> ← <valeur à <valeur par <valeur faire

initiale> finale> du "pas">
traitement
type entier ou
réel,
le même pour valeur dont varie la variable de boucle
ces 4 entre deux passages dans la boucle,
informations à 1 par défaut (peut être négatif)

Sémantique de la boucle pour
• Implicitement, l’instruction pour:

- initialise une variable de boucle (le compteur)
- incrémente cette variable à chaque pas
- vérifie que cette variable ne dépasse pas la borne
supérieure
• Attention :
- le traitement ne doit pas modifier la variable de boucle
pour cpt Å 1 à MAX faire

si (…) alors cpt Å MAX Interdit !
fpour

Quand le nombre d'itérations
n’est pas connu...
Algorithme FaitLeTotal
{Cet algorithme fait la somme des données qu’il saisit, arrêt à la lecture de -1)
constante (STOP : entier) ← -1
variables val, totalValeurs : entiers
début
totalValeurs ← 0
afficher("Donnez une valeur, " , STOP, " pour finir.") {amorçage}
saisir(val)
tant que val ≠ STOP faire
totalValeurs ← totalValeurs + val {traitement}
afficher("Donnez une autre valeur, " , STOP, " pour finir.")
saisir(val) {relance}
ftq
afficher("La somme des valeurs saisies est " , totalValeurs)
fin
Simulation de la boucle tant que
• Données : 3 -3 10 -1
STOP = −1
• Affichage :

La boucle « tant que … faire »
amorçage {initialisation de la (des) variable(s) de condition}

tant que <expression logique (vraie)> faire
relance {ré-affectation de la (des) variable(s) de condition}
ftq
• Fonction:
- répéter une suite d’instructions tant qu’une condition est
remplie
remarque : si la condition est fausse dès le départ, le
traitement n’est jamais exécuté
Sémantique de la boucle tant que
amorçage: initialisation
de la variable de condition
condition d'exécution
du traitement
saisir(val)
tant que val ≠ STOP faire
totalValeurs ← totalValeurs + val
afficher("Donnez une autre valeur, " , STOP, " pour finir. " )
saisir(val)
ftq traitement
afficher("La somme des valeurs saisies est " , totalValeurs)
à exécuter
relance: si la condition
ré-affectation est vérifiée
affichage de la variable
résultats de condition

Comparaison boucles pour et tant que
pour cpt ← 1 à nbVal faire
saisir(valeur)
fpour
...équivaut à :
cpt ← 0
tant que cpt < nbVal faire
saisir(valeur)
cpt ← cpt + 1 {compte le nombre de valeurs traitées}
ftq
Comparaison boucles pour et tant que
(suite)
• Implicitement, l’instruction pour:

- initialise un compteur
- incrémente le compteur à chaque pas
- vérifie que le compteur ne dépasse pas la borne supérieure
• Explicitement, l’instruction tant que doit
- initialiser un compteur {amorçage}
- incrémenter le compteur à chaque pas {relance}
- vérifier que le compteur ne dépasse pas la borne supérieure
{test de boucle}

Choisir pour... Choisir tant que...
si le nombre d’itérations est connu à l’avance,

Î choisir la boucle pour
si la boucle doit s'arrêter quand survient un

évènement ,
Î choisir la boucle tant que

La boucle répéter : un exemple
Algorithme Essai
{Cet algorithme a besoin d’une valeur positive paire}
variables valeur : entier
début
répéter
afficher("Donnez une valeur positive non nulle : ")
saisir(valeur)
tant que valeur ≤ 0
afficher("La valeur positive non nulle que vous avez saisie est ")
afficher( valeur )
… {traitement de la valeur saisie}
fin
Simulation de la boucle répéter
• Données : -2 0 4
• Affichage :

La boucle « répéter ...tant que »
répéter
(ré)affectation de la (des) variable(s) de
condition
tant que <expression logique (vraie)>
• Fonction:
- exécuter une suite d’instructions au moins une fois et
la répéter tant qu’une condition est remplie
Remarque: le traitement dans l’exemple précédent se
limite à la ré-affectation de la variable de condition
Comparaison boucles
répéter et tant que
répéter
afficher("Donnez une valeur positive paire :")
saisir(valeur)
tant que (valeur < 0 ou (valeur % 2) ≠ 0)
...équivaut à :
afficher("Donnez une valeur positive paire :")
saisir(valeur)
tant que (valeur < 0 ou (valeur % 2) ≠ 0) faire
afficher("Donnez une valeur positive paire:")
saisir(valeur)
ftq
Comparaison boucles
répéter et tant que (suite)
• boucle tant que
- condition vérifiée avant chaque exécution du traitement
- le traitement peut donc ne pas être exécuté
- de plus : la condition porte surtout sur la saisie de nouvelles
variables (relance)
• boucle répéter tant que
- condition vérifiée après chaque exécution du traitement
- le traitement est exécuté au moins une fois
- 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.
Choisir pour... tant que… répéter…
Boucle tant que

on
Traitement n
exécuté au moins
une fois ?
non
ou
Nombre
Boucle répéter
i
d’itérations
connu ?
oui
Boucle pour

Remarque
fsi, ftq et fpour peuvent être omis si le corps

se limite à une seule instruction
Exemples:
si val > 0 alors afficher(« fini! »)
pour i ← 1 à MAX faire afficher(i × val)

Le problème d’une boucle : il faut en sortir!
tant que A faire B

répéter B tant que A
• quelque chose dans la suite d’instructions B doit
amener A à prendre la valeur Faux.
→ la suite d’instructions B doit modifier au moins une variable de
l’expression logique A
→ (mauvais) exemple : val1 Å 2 ; val2 Å 3
tant que val1 < 100 faire
val2 Å val2 × val1
ftq
• c’est l’expression logique A (et elle seule!) qui en
prenant la valeur Faux provoque l’arrêt de la boucle.
De l'énoncé à la boucle
saisir(val)
afficher le carré des
valeurs saisies tant tant que val ≠ 0 faire
qu’on ne saisit pas 0 afficher(val × val)
saisir(val)
ftq
saisir(val)
saisir des données
et s'arrêter dès que somme ← val
leur somme tant que somme ≤ 500 faire
dépasse 500 saisir(val)
somme ← somme + val
ftq
De l'énoncé à la boucle (suite)
saisir des données

et s'arrêter dès que somme ← 0
leur somme répéter
dépasse 500 saisir(val)
tant que somme ≤ 500
saisir des données

tant que leur somme
ne dépasse un seuil
donné

Exemple d’un mauvais choix de boucle
Algorithme Somme
{Cet algorithme fait la somme d’une suite de nombres tant que cette somme
ne dépasse un seuil donné)
variables val, somme : entiers
début
somme ← 0
répéter
afficher( "Entrez un nombre")
saisir(val)
tant que somme ≤ SEUIL
afficher( "La somme atteinte est" , somme - val)
fin

Version corrigée
Algorithme Somme
{Cet algorithme fait la somme d’une suite de nombres tant que cette somme
ne dépasse un seuil donné)
variables val, somme : entiers
début

Quand utiliser la boucle tant que?
• Structure itérative "universelle"

n'importe quel contrôle d'itération peut se traduire par le
"tant que "
• Structure itérative irremplaçable dès que la

condition d'itération devient complexe
Exemple:
saisir des valeurs, les traiter, et s’arrêter à la saisie de
la valeur d’arrêt –1 ou après avoir saisi 5 données.

Exemple
constantes (STOP : entier) ← -1
(MAX : entier) ← 5
variables nbVal , val : entiers
début
nbVal ← 0 {compte les saisies traitées}
saisir(val) {saisie de la 1ère donnée}
tant que val ≠ STOP et nbVal < MAX faire
nbVal ← nbVal + 1
ftq
afficher(val, nbVal) {valeurs en sortie de boucle}
…
Attention :
La valeur d’arrêt n’est jamais traitée (et donc, jamais comptabilisée)
Simulation de la boucle
test 1 : 3 5 -1 test 3 : 3 5 -6 4 0 –1
test 2 : 3 5 -6 4 0 8 test 4 : -1

Interpréter l'arrêt des itérations
nbVal ← 0 {compte les saisies traitées}
saisir(val) {saisie de la 1ère donnée}
nbVal ← nbVal + 1
ftq
si val = STOP
alors {la dernière valeur testée était la valeur d’arrêt}
afficher(« Sortie de boucle car saisie de la valeur d’arrêt;
toutes les données significatives ont été traitées. »)
sinon {il y avait plus de 5 valeurs à tester}
afficher(« Sortie de boucle car nombre maximum de valeurs
à traiter atteint; des données significatives n’ont pas
pu été traitées. ")
fsi
De l’importance du test de sortie
de boucle (… et donc de la logique)
• dans la boucle : val ≠ STOP et nbVal < MAX est vrai

• à la sortie de boucle :
• soit val ≠ STOP est faux Æ val = STOP
• soit nbVal < MAX est faux Æ nbVal ≥ MAX
• que tester à la sortie de boucle?
• si val = STOP alors … voir transparent précédent.
• si nbVal ≥ MAX alors … mauvais test car message dépend
de la dernière valeur saisie.
Conclusion: Quelques leçons à retenir
• Le moule d'un algorithme
Algorithme AuNomEvocateur
{Cet algorithme fait..............en utilisant telle et telle donnée.........}
constantes
variables
début
{préparation du traitement : saisies,....}
{traitements, si itération, la décrire }
{présentation des résultats: affichages,... }
fin
• Il faut avoir une écriture rigoureuse
Il faut avoir une écriture soignée : respecter l’indentation
Il est nécessaire de commenter les algorithmes
• Il existe plusieurs solutions algorithmiques à un problème posé

Il faut rechercher l’efficacité de ce que l’on écrit

Logique propositionnelle
Algorithmique 1 : Logique 57
En quoi la logique est-elle utile au
programmeur ?
• La logique : une façon de formaliser notre

raisonnement
• Il n’y a pas une logique mais DES logiques
• La logique propositionnelle : modèle
mathématique qui nous permet de raisonner sur la
nature vraie ou fausse des expressions logiques
Retour sur les conditions d'itération
tant que somme ≤ SEUIL faire...

tant que val ≠ STOP et nbVal < MAX faire …
tant que valeur < 0 ou (valeur % 2) ≠ 0 faire...
Proposition :
expression qui peut prendre la valeur VRAI ou FAUX
Exemples de propositions:
2 et 2 font 4
1 et 1 font 10
il pleut
x>y
Eléments de logique propositionnelle
• Formule :
- expression logique composée de variables
propositionnelles et de connecteurs logiques
• Variable propositionnelle :
- une proposition considérée comme indécomposable
• Connecteurs logiques:
- négation non, ¬ - conjonction et, ∧
- implication ⇒ - disjonction ou, ∨
• Exemple : p et q variables propositionnelles
((¬ p ∨ q) ∧ ¬ q) ∨ (p ∨ ¬ q)
Représentations d'une formule
∨
(p ∧ q) ∨ ((¬p ∧ r) ∨ ¬p ) ∧ ∨
p q ∧ ¬
Par un arbre syntaxique :
¬ r
p p
En utilisant la notation préfixée (polonaise) :
∨∧pq∨∧¬pr¬p
En utilisant la notation postfixée :

p q ∧p ¬ r ∧ p ¬ ∨ ∨
Tables de vérité
Représentation des valeurs de vérité
associées à une expression logique
Négation Conjonction Disjonction Implication

p ¬p p q p∧q p q p∨q p q p→q
V F V V V V V V V V V
F V V F F V F V V F F
F V F F V V F V V
F F F F F F F F V
p et q : variables propositionnelles
Equivalences classiques
• Commutativité
- p∧q équivalent à q∧p
- p∨q équivalent à q∨p
• Associativité
- p ∧ (q ∧ r) équivalent à (p ∧ q) ∧ r
- p ∨ (q ∨ r) équivalent à (p ∨ q) ∨ r
• Distributivité
- p ∧ (q ∨ r) équivalent à (p ∧ q) ∨ (p ∧ r)
- p ∨ (q ∧ r) équivalent à (p ∨ q) ∧ (p ∨ r)
Equivalences classiques (suite)
• Lois de Morgan
¬ (p ∧ q) équivalent à (¬ p) ∨ (¬ q)
¬ (p ∨ q) équivalent à (¬ p) ∧ (¬ q)
p q p ∧q ¬(p ∧q) ¬p ¬q ¬p ∨ ¬q
Formules :
quelques classes et relations
• Les tautologies :
- vraies pour toute assignation de valeurs de vérité aux
variables. p ¬p p∨¬p
- exemple : p ∨ ¬ p
• Les formules contradictoires :

- fausses pour toute assignation de valeurs de vérité aux
variables. p ¬p p∧¬p
- exemple : p ∧ ¬ p
Formules :
quelques classes et relations (suite)
• Les formules équivalentes:
- même valeur de vérité pour toute assignation de la même
valeur de vérité aux variables.
- exemples : p ⇒ q est équivalent à ¬ p ∨ q
p ⇒ q est équivalent à ¬ q ⇒ ¬ p
p q p⇒q ¬p q ¬p∨q
Du bon usage de la logique
Vérification de l'équivalence de deux formules
"être mineur (p) ou majeur (¬p) non imposable (q) "

équivaut à "être mineur (p) ou non imposable (q) "
p q ¬p∧q p∨(¬ p∧q) p∨q
Applications à l'algorithmique
• Interpréter (et bien comprendre!) l’arrêt des itérations
à la sortie d’une boucle.
tant que <cond> faire
À la sortie : non(<cond>) est vrai
donc si cond = p et q
à la sortie : non (p et q)
c’est a dire non p ou non q
Exemple : avec <cond> égal à : val ≠ STOP et nbVal < MAX

non(<cond>) égal à : val = STOP ou nbVal ≥ MAX
Applications à l'algorithmique (suite)
• Simplifier une écriture par substitution d'une formule
équivalente
si (Age = "Mineur"
ou (non (Age = "Mineur") et non (Fisc = "Imposable"))) alors...
Equivalent à :
si (Age = "Mineur" ou non (Fisc = "Imposable")) alors...
• Vérifier la validité d'une condition

si Valeur< 10 et Valeur >100 alors… Å cas improbable
• Ecrire la négation d’une condition

si on veut P et Q et R :
répéter …. tant que non P ou non Q ou non R ou …
Le Type BOOLEEN
• Deux constantes booléennes :

VRAI , FAUX
• Des variables de type booléens :
variables ok, continuer : booléen
ok ← (rep = ‘ O ’ ou rep = ‘ o ’)
continuer ← (val > O et val < 9)
• Dans les conditionnelles et itératives :
tant que ok faire …
si continuer alors ...
Le Type BOOLEEN : exemple
Algorithme Logique
constantes (MAX : entier) ← 5
(STOP : entier) ← -1
variables nbVal, val : entiers
ok : booléen
début
nbVal ← 0
saisir (val)
ok ← val ≠ STOP et nbVal < MAX {initialisation de la variable
tant que ok faire de boucle booléenne }
nbVal ← nbVal + 1
saisir(val)
ok ← val ≠ STOP et nbVal < MAX {relance}
ftq
si val = STOP alors ...
Booléens : encore des exemples
variables val : entier

encore : booléen
début
encore ← faux encore ← faux
val ← 0 val ← 0
répéter tant que non encore faire
afficher( "bonjour " ) val ← val + 1
val ← val – 1 afficher(val )
encore ← val > 0 encore ← val > 2
tant que encore ftq
afficher( "fini " ) afficher( "fini " )
fin
fin Volume 1
Algorithmique 1 73
Université Paris XI
iUT ORSAY I.U.T. d'Orsay
Département Informatique
Année scolaire 2003-2004
Algorithmique : Volume 2
• Tableaux
• Sous-algorithmes
• Modularité
Cécile Balkanski, Nelly Bensimon, Gérard Ligozat

Tableaux
Algorithmique 2 : Tableaux 1
Ensemble de données du même type
Exemple de problème :
Saisir une suite de nombres, puis afficher cette suite après avoir
divisé tous les nombres par la valeur maximale de la suite.
Nécessité de conserver les nombres en mémoire
variable contenant une valeur variable contenant une collection de

valeurs du même type
val 132
val 132 52 -57 -8902 -841 8100 –641
Remarque : appeler cette variable tabVal

plutôt que val
Les tableaux
Structure de données permettant d'effectuer un même
traitement sur des données de même nature
tableau à une
dimension
tableau à deux
dimensions
Exemples d'applications
• Ensemble de valeurs entières, réelles,

booléennes,....
• Ensemble de noms (type chaîne)
• Ensemble de caractères (type caractère)
• Ensemble d'adresses (type Adresse : nom,
adresse, num téléphone)
• Ensemble d'ouvrages
Traitements opérant sur des tableaux
On veut pouvoir :
- créer des tableaux
- ranger des valeurs dans un tableau
- récupérer, consulter des valeurs rangées dans un
tableau
- rechercher si une valeur est dans un tableau
- mettre à jour des valeurs dans un tableau
- modifier la façon dont les valeurs sont rangées dans un
tableau (par exemple : les trier de différentes manières)
- effectuer des opérations entre tableaux : comparaison
de tableaux, multiplication,...
- ...
nom du
Définition du type
indice
tableau du tableau
1 2 3 4 5 6
tab contenu
12 5 -78 2 -21 8
du tableau
1 2 3 4 5 6 7 8
unTab
p i s c i n e s
Remarques :
• Indices : en général, démarrage à 1, mais en C++, démarrage à 0
• Nombre d’octets occupés : dépend du type des valeurs enregistrées
Déclaration d'un tableau
Exemple : déclaration d'un tableau pouvant contenir jusqu'à 35 entiers
variable tabl : tableau [1, 35 ] d'entiers
mot clé type des éléments

nom du tableau
indices min et max
(taille)
Autre exemple : déclaration d'un tableau qui contiendra les fréquences des
températures comprises entre –40°C et 50°C
variable températures : tableau [-40, 50] de réels

Les éléments
Algorithmique 2 : Tableaux sont numérotés 7
de -40 à 50
Définition d'un type tableau
type <Nom> = <description>
Exemple : déclaration d'un nouveau type Mot,

tableau de 10 caractères
type Mot = tableau [1, 10 ] de caractères

variables nom, verbe : Mot
Utilisation d’un tableau :
par les indices
• Accès en lecture :
- afficher(tabl[4]) {le contenu du tableau à l’indice
4 est affiché à l’ écran}
• Accès en écriture :
- tabl[3] ←18 {la valeur 18 est placée dans le
tableau à l’indice 3}
- saisir(tabl[5]) {la valeur entrée par l’utilisateur est
enregistrée dans le tableau à l’indice 5}
- attention!
tabl Å18 nom[2] Å 3
Tableaux à deux dimensions
1 2 3 4 5 6 7
1 10 3 25 14 2 1 8
2 9 20 7 12 2 4 7
tableau à 2 lignes et 7 colonnes
• Déclaration
points : tableau[1,2 ; 1,7] d’entiers
indices min et max indices min et max

des lignes des colonnes
Tableaux à deux dimensions (suite)
1 2 3 4 5 6 7
1 10 3 25 14 2 1 8
2 9 20 7 12 2 4 7
• Accès en lecture :
- afficher(points[1,7]) {la valeur contenue en ligne 1 colonne 7 est
affichée à l’écran}
• Accès en écriture :
- points[2,4] ← 36
- saisir(points[2,4]) {la valeur fournie est enregistrée en ligne 2,
colonne 4}
Saisir les valeurs d'un tableau 1D
Algorithme SaisieTableau
{remplit un tableau avec nbVal valeurs entières }
constantes (TailleMAX : entier) ← 100
variables nbVal, ind : entier
nombres : tableau [1, TailleMAX] d'entiers
début
afficher ("Combien de valeurs sont à saisir?")
saisir (nbVal)
si nbVal > TailleMAX
alors {refuser la saisie : la capacité du tableau est dépassée}
afficher ("trop de valeurs à saisir")
sinon pour ind ← 1 à nbVal faire
afficher ("Donner une valeur")
{valeur à ranger dans la indème case du tableau}
saisir (nombres[ind])
fpour
fsi
fin
Saisie avec « Drapeau »
Algorithme SaisieTableauAvecDrapeau
{remplit un tableau tant qu'il y a des caractères à ranger, dernier caractère : '\'}
(DRAPEAU : caractère) ← '\'
variables nbLettres : entier {nombre de caractères rangés dans lettres}
lettres : tableau [1, TailleMAX] de caractères
unCar : caractère
début
nbLettres ← 0
{saisie du premier caractère à ranger dans Lettres}

afficher (« Tapez un caractère, ou ", DRAPEAU, "pour arrêter la saisie. ")
saisir (unCar )
(Saisie avec Drapeau, suite)
{rangement du caractère saisi s’il est bon et saisie des caractères suivants}
tant que unCar ≠ DRAPEAU et nbLettres < TailleMAX faire
nbLettres ← nbLettres + 1
lettres[nbLettres ] ← unCar {caractère rangé dans la nbLettresème
case du tableau}
afficher (" Tapez un autre caractère, ou ", DRAPEAU, "pour arrêter la saisie."
saisir (unCar ) {saisie du caractère suivant}
ftq
le caractère ne sera rangé dans le tableau que
{test de sortie de boucle} s'il est ≠ '\‘ et si TailleMAX non atteinte
si unCar = DRAPEAU
alors afficher ("Valeurs saisies intégralement.")
sinon afficher ("Trop de caractères à saisir, plus de place ! ")
fsi
fin
Remarque : si unCar est différent de DRAPEAU, on est certainement sorti de la boucle

parce que nbLettres est égal à TailleMAX.
Simulation de la saisie
Attention !
• Le drapeau ne doit PAS être rangé dans le tableau
• Le test de sortie ne peut pas être remplacé par

si nbLettres = TailleMAX
alors afficher ("Trop de caractères à saisir,
plus de place ! ")
sinon afficher ("Valeurs saisies intégralement.")
fsi
• Ne pas confondre
- taille maximale : TailleMAX (une constante)
- taille effective : nbLettres (une variable)
Affichage d’un tableau
Algorithme SaisitEtAffiche
{saisit et affiche un tableau de caractères}
constantes {voir transparents précédents}
variables {voir transparents précédents}
début
{saisie du tableau : voir transparents précédents}
{affichage}
afficher ("Voici les", nbLettres, "caractères saisis dans le tableau :")
pour cpt Å 1 à nbLettres faire
afficher (lettres[cpt])
fpour
fin ATTENTION
exécuter la boucle
seulement nbLettres fois!
Saisir les valeurs d'un tableau 2D
Algorithme SaisieTableau2D
{remplit un tableau à 2 dimensions }
variables nbLignes, nbColonnes, indL, indC : entiers
nombres : tableau [1, TailleMAX ; 1, TailleMAX] d'entiers
début
afficher ("Combien de lignes?") ; saisir (nbLignes)
afficher ("Combien de colonnes?") ; saisir (nbColonnes)
si nbLignes > TailleMAX ou nbColonnes > TailleMAX
alors afficher ("trop de valeurs à saisir")
sinon pour indL ← 1 à nbLignes faire
pour indC ← 1 à nbColonnes faire
afficher ("Ligne" , inL, "colonne", indC, " : ")
saisir (nombres[indL indC])
fpour
fpour
fsi
fin
Simulation
Sous-algorithmes
1. Motivation, définitions, et simulation

2. Analyse à l’aide de sous-algorithmes
3. Retour aux tableaux: procédures et fonctions
de manipulation de tableaux
Algorithmique 2 : Sous-algorithmes 20
Identifier le rôle d'un bloc d'instructions
Algorithme Puissances
variables uneVal, puissance : réels
cpt, nbPuissances : entiers
début
afficher ("Donnez un nombre réel quelconque : ")
saisir (uneVal)
afficher ("Combien de puissances successives souhaitez-vous ? ")
saisir (nbPuissances)
{calcul des nbPuissances puissances successives de uneVal }
puissance Å 1
pour cpt Å 1 à nbPuissances faire
puissance Å puissance × uneVal
afficher ("La", cpt, "ième puissance de", uneVal, "est", puissance )
fpour
fin
En simplifiant l'écriture...
variables uneVal : réel
nbPuissances : entier
début
afficher ("Donnez un nombre réel quelconque : ")
saisir (uneVal)
afficher ("Combien de puissances successives souhaitez-vous ?
saisir (nbPuissances)
calculPuissances(uneVal, nbPuisssances)
fin
sous-algorithme
détaillé ailleurs,
opérant le traitement
Nouveau schéma d'un algorithme
Algorithme
Données Résultats
initialisation Communication
traitement
du traitement des résultats
se ré-écrit en :
Algorithme
Données Sous- Sous-
algorithme1 algorithme3
Résultats
Sous- Sous-
Sous-algorithmes
• Un algorithme appelle un sous-algorithme : cet algorithme

passe "momentanément" le contrôle de l'exécution du
traitement au sous-algorithme.
• Un sous-algorithme est conçu pour faire un traitement

bien défini, bien délimité, si possible indépendamment du
du contexte particulier de l’algorithme appelant.
• Remarque : un sous-algorithme peut en appeler un autre.
Comment les informations circulent...
Algorithme sous-
sous-
informations retournées
informations transmises
par les sous-algorithmes
par l'algorithme principal
à l'algorithme principal
aux sous-algorithmes
sous- sous-
Exemple
nbPuissances : entier Algorithme
début
afficher (" … ") Puissances
saisir (uneVal)
afficher (" … ")
uneVal
saisir (nbPuissances) nbPuissances
calculPuissances(uneVal, nbPuisssances) uneVal
fin nbPuissances
calculPuissances
nbPuissances : entier
début
saisirDonnées(uneVal, nbPuisssances) saisirDonnées
fin
Communications d’informations
Algorithme sous-algorithme
paramètre en « Donnée » noté (D)
paramètre en « Résultat » noté (R)
paramètre en « Donnée et Résultat » noté (D/R)
Paramètres et Arguments
variables uneVal : réels arguments de l’appel
nbPuissances : entier de la procédure
début
…
…
fin
Procédure calculPuissance(val, nb)

paramètre (D) val : réel
(D) nb : entier
début paramètres
.... de la procédure
fin
Algorithme appellant données sous-algorithme appellé

ARGUMENTS PARAMETRES
résultats
Au moment de l'appel du sous-algorithme, les valeurs des

arguments sont affectés aux paramètres de statut (D) ou (D/R) :
- premier paramètre (si (D) ou (D/R)) Å premier argument
- deuxième paramètre (si (D) ou (D/R)) Å deuxième argument
- etc.
A la sortie du sous-algorithme, les valeurs des paramètres de
statut (R) ou (D/R) sont affectés aux arguments correspondants :
- premier argument Å premier paramètre (si (R) ou (D/R))
- deuxième argument Å deuxième paramètre (si (R) ou (D/R))
- etc.
• Le nombre de paramètres doit correspondre au nombre
d’arguments.
• Le type du kième argument doit correspondre au type du
kième paramètre.
• Le nom du kième argument a, de préférence, un nom
différent de celui du kième paramètre.
• Un paramètre défini en "Donnée" doit correspondre à un
argument qui possède une valeur dans l’algorithme appelant
au moment de l’appel.
• Un paramètre défini en "Résultat" doit recevoir une valeur
dans le sous-algorithme.
Procédure : formalisation syntaxique
nom de la procédure liste des
paramètres spécification
de la procédure
Procédure calculPuissance(val, nb)
{calcule et affiches les nb puissances de val}
paramètres (D) nb : entier
(D) val : réel déclaration
variables cpt : entier des paramètres
(attributs, nom, type)
puisssance : réel
début
variables locales
puissance Å 1
à la procédure
pour cpt Å 1à nb faire
puissance Å puissance × val corps de la
afficher ("La", cpt, "ième puissance de", val, "est", procédure
puissance )
fpour
fin
Fonctions
Une fonction est un sous-algorithme qui

retourne une valeur.
Algorithme surfaceRect
variables aire, long, larg : réels
début
afficher ("Donnez la longueur et la largeur de votre rectangle : ")
saisir (long, larg)
aire Å surface(long,larg)
afficher ("Voici sa surface : ", aire) sous-algorithme
fin détaillé ailleurs,
opérant le traitement,
et retournant une
Fonction : formalisation syntaxique
nom de liste des type de la
la fonction paramètres valeur retournée
spécification
Fonction surface (longueur, largeur) retourne (réel)

{retourne la surface d'un rectangle à partir de sa longeur et de sa largeur}
paramètres (D) longueur, largeur : réel
variable résultat : réel déclaration
début des paramètres
résultat Å longeur × largeur variable locale (attributs, nom, type)
retourne (résultat) à la fonction
fin
instruction
indispensable !
Attention : pas de paramètre de statut (R) pour la valeur retournée

Comparaison : Fonctions et Procédures
• Définition :
Procédure surf1(long,larg, aire) Fonction surf2(long,larg) retourne réel
paramètres (D) long, larg : réel paramètres (D) long, larg : réel
(R) aire : réel variable aire : réel
début début
aire Å long × larg aire Å long × larg
fin retourne (aire)
fin
• Utilisation (appel):
Algorithme Exemple
variables surface, longueur, largeur : réel
début
longueur Å 10 ; largeur Å 25
surf1(longueur, largeur, surface) {utiliser surf1
surface Å surf2(longueur, largeur) ou surf2}
fin Algorithmique 2 : Sous-algorithmes 34
Caractéristiques des deux classes de
sous-algorithmes
• Une procédure, comme une fonction, est appelée dans
un algorithme par son nom suivi de la liste des arguments
correspondant à sa liste de paramètres.
• Lors de l'appel d'une fonction, la valeur retournée doit
être exploitée dans une instruction (affectation, expression
arithmétique ou logique, affichage, ...).
• Dans une fonction, la valeur retournée explicitement
remplace le paramètre d'attribut résultat (R) auquel on
veut donner une importance particulière.
• Dans une procédure comme dans une fonction, la liste
des paramètres peut être vide.
Simulation de sous-algorithmes
Algorithme calculNotes
{calcule la moyenne des notes saisies }
variables note, somme, moyenne : réel
nbnotes : entier ; ok : booléen
début
somme Å 0 ; nbnotes Å 0 {initialisations}
afficher ("Donnez la première note (note négative pour terminer)")
saisir(note)
tant que note ≥ 0 faire {traitement : saisies des notes et calcul du total}
compter(note, somme, nbnotes)
afficher ("Donnez la note suivante (note négative pour terminer) " )
saisir(note)
ftq
ok Å calculMoyenne(somme,nbnotes,moyenne) {calcul moyenne}
si ok {affichage résultat}
alors afficher("La moyenne des ", nbnotes, "notes est", moyenne)
sinon afficher("Pas de notes, pas de moyenne!")
fin
Procédure compter(uneNote, laSomme, nb)
{Ajoute uneNote à laSomme et incrémente nb}
paramètres
début
Fonction calculMoyenne(laSomme, nb, laMoyenne) retourne booléen

{Calcule la moyenne des nb notes dont le total est laSomme; retourne vrai si calcul possible,
faux sinon}
paramètres
variable
début
Un autre exemple
Algorithme UnTest
{Cet algorithme mesure votre capacité à suivre des appels de
sous-algorithmes}
variables a,b,c : entiers
début
aÅ1
bÅ2
afficher ("Entrée : (a, b) = (", a , b , ")" )
test1(a,b,c)
afficher ("Sortie : (a, b, c) = (", a , b , c, ")" )
fin
Un autre exemple (suite)
Procédure test1(x, y, z) Fonction test2(v1, v2) retourne entier

paramètres (D) x : entier paramètres (D) v1 : entier
(D/R) y : entier (D/R) v2 : entier
(R) z : entier variable rés : entier
début début
xÅx+1 afficher ("début test2 : (v1, v2) = (",
yÅy+1 v1, v2, ")" )
z Å test2(x , y) v1 Å v1 + 1
afficher ("fin test1 : (x, y, z) = (", v2 Å v2+ 1
x , y , z , ")" ) rés Å v1 + v2
fin retourner(rés)
fin
Simulation
Sous-algorithmes
2. Analyse à l’aide de sous-algorithmes
Problème :
A partir
- du jour de la semaine (chiffre entre 1(=lundi) et 7(=dimanche)),
- et de la date présentée sous le modèle AAAAMMJJ,
afficher la date du jour "en clair"
Exemple :
à partir des données : 2 20031014
affichage :
"Nous sommes le mardi 14 octobre 2003"
2 hypothèses de travail :
- l'utilisateur ne saisit que des chiffres
- l'utilisateur peut se tromper sur la cohérence des données
Algorithme principal
Algorithme AffichageDate
{faire un affichage lisible d'une date}
variables
début
{saisie des données}
saisieJourSemaine(
saisieDate(
{extraction des 4 chiffres de gauche dans la date}
calculAnnée(
{extraction des 5ème et 6ème chiffres de la date, et
conversion dans le mois correspondant}
calculMois(
{extraction des 2 chiffres de droite dans la date}
calculJour(
{présentation de la date}
afficherDate(
fin Algorithmique 2 : Sous-algorithmes 45
Analyse de la circulation d'informations
saisieDate
saisieJourSemaine
afficherDate
calculAnnée
calculMois calculJour
Détail des procédures (1)
Procédure saisieJourSemaine(nom)
{saisit le numéro du jour et retourne le nom du jour dans nom }
paramètre (R) nom : chaîne
variable locale
à la procédure
variable numJ : entier
début
répéter
afficher ("Donnez le numéro du jour dans la semaine (nombre
compris entre 1 et 7) :")
saisir (numJ )
tant que numJ < 1 ou numJ > 7
nom ← nomJourSemaine(numJ)
fin sous-algorithme qui
retourne le nom du (num_J)ème
jour de la semaine
Procédure saisieDate(laDate)
{saisit la date sous forme d'une chaîne, en vérifie la cohérence, puis
retourne dans laDate la chaîne convertie en entier}
paramètre (R) laDate : entier
sous-algorithme
variable unJour : chaîne qui vérifie la cohérence
début de la date
répéter
afficher ("Donnez la date (sous la forme AAAAMMJJ) :")
saisir (unJour)
tant que non dateValide(unJour)
laDate ← convertir(unJour)
fin sous-algorithme
qui transforme la chaîne
unJour en un entier
Procédure calculAnnée(laDate, année)
{isole l'année année dans la date laDate (4 chiffres de gauche)}
paramètres (D) laDate, (R) année :entier
début
année ← laDate div 10 000
fin
Procédure calculMois(laDate, leMois)

{isole le mois leMois dans la date ( chiffres des milliers et des centaines)}
paramètres (D) laDate : entier
(R) leMois : chaîne
variables unMois : entier
début
unMois ← (laDate mod 10 000) div 100 sous-algorithme
leMois ← nomMois(unMois) qui retourne le nom du
fin (unMois)ème mois
Procédure calculJour(laDate, leJour)
{isole le jour leJour dans la date laDate (2 chiffres de droite)}
paramètres (D) laDate, (R) leJour :entier
début
leJour ← laDate mod 100
fin
Procédure afficherDate(nomJ, jour, mois, année)

{affiche la date de façon bien lisible}
paramètres (D) nomJ, (D) nomM : chaînes
(D) jour, (D) année : entiers
début
afficher (" Nous sommes ", nomJ, " le ", jour, " ", nomM , " ", année )
fin
Détail des fonctions (1)
Fonction nomJourSemaine(numJ) retourne (chaîne)
{retourne le nom du (numJ) ème jour de la semaine}
paramètres (D) numJ : entier
variable leJour : chaîne
début
selon numJ :
1: leJour ← "Lundi"
2: leJour ← "Mardi"
3: leJour ← "Mercredi"
4: leJour ← "Jeudi"
5: leJour ← "Vendredi"
6: leJour ← "Samedi"
7: leJour ← "Dimanche"
retourne (leJour )
fin
Remarque : même genre de fonction pour nomMois(numM)
Hiérarchie des appels
de sous-algorithmes
Remarque : procédure ou fonction?
Fonction dateValide (leJour) retourne (booléen) Procédure dateValide (leJour, bon)

{…} {…}
paramètres (D) leJour : chaîne paramètres (D) leJour : chaîne
variable bon : booléen (R) bon : booléen
début
début
… bon Å …
…
retourne (bon)
bon Å …
fin
fin
À l'appel (dans procédure saisieDate) :
9 version fonction : tant que non dateValide(unJour) faire
x version procédure : tant que non dateValide(unJour, bon) faire
Remarque : procédure ou fonction? (suite)
Fonction convertir (leJour) retourne (entier) Procédure convertir (leJour, uneDate)

{…} {…}
paramètres (D) leJour : chaîne paramètres (D) leJour : chaîne
variable uneDate : entier (R) uneDate : entier
début début
… uneDate Å … …
retourne (uneDate) uneDate Å …
fin fin
À l'appel (dans procédure saisieDate) :
9 version fonction : laDate Å convertir(unJour)
9 version procédure : convertir(unJour, laDate)
Remarque : procédure ou fonction? (suite)
Fonction saisieDate() retourne (entier) Procédure saisieDate(uneDate)

{…} {…}
variable uneDate : entier paramètres (R) uneDate : entier
début début
… uneDate Å … …
retourne (uneDate) uneDate Å …
fin fin
À l'appel (dans algorithme DateEnClair) :
9 version fonction : date Å saisieDate()
9 version procédure : saisieDate(date)
Bilan :
Intérêt de la programmation modulaire
• Permettre une analyse descendante d'un problème :
- identifier les différents traitements contribuant au travail demandé
- organiser l'enchaînement des étapes
• Permettre une mise au point progressive, module par module
• Faciliter la maintenance des programmes

- modifier le traitement lui-même sans changer le rôle particulier d'un module
• Enrichir le langage algorithmique en ajoutant de nouveaux "mots"

du langage
- notion de "boite à outils", de bibliothèques de composants logiciels
réutilisables
Sous-algorithmes
3. Retour aux tableaux :

Procédures et fonctions de manipulation de tableaux
Algorithmique 2 : Tableaux (suite) 57

Algorithme TraiterTableau
{saisit puis effectue des traitements sur une tableau d'entiers}
constantes (MAX : entier) Å 100
(DRAPEAU : entier) ← 12345
variables nbVal, uneVal, ind : entiers
valeurs : tableau [1, MAX] de entiers
ok : booléen
début
{remplissage du tableau}
{vérification de la saisie}
{affichage du contenu du tableau}

(suite Algorithme TraiterTableau)
{somme des éléments du tableau}
{recherche d ’un élément dans le tableau}

Procédure saisieTableau (tab, nbElt, correct)
{remplit le tableau tab tant qu'il y a des valeurs à ranger; retourne tab, sa taille effective
nbElt, et correct à vrai si pas de pb}
paramètres (R) tab : tableau [1, MAX] de entiers
(R) nbElt : entier ;
(R) correct : booléen
variables uneVal : entier
début
afficher ( "Donnez une valeur, ou bien", DRAPEAU, "pour arrêter la saisie.")
saisir (uneVal )
nbElt Å 0
tant que uneVal ≠ DRAPEAU et nbElt < MAX faire
nbElt Å nbElt + 1
tab[nbElt ] Å uneVal
afficher ("Donnez une autre valeur, ", DRAPEAU, "pour arrêter.")
saisir (uneVal )
ftq
correct Å (uneVal = DRAPEAU) {vrai si la dernière valeur saisie était
fin le drapeau}
Procédure afficheTableau (tab, nbElt)
{affiche les nb valeurs du tableau tab}
paramètres tab : tableau [1, MAX] de entiers
nbElt : entier
variables ind : entier
début
Fonction sommeTab (tab, nbElt) retourne entier

{retourne la somme des nb éléments du tableau tab}
nbElt : entier
variables ind, total : entiers
début

Fonction recherche (tab, nbElt, uneVal, ind) retourne booléen
{Recherche le premier indice où se trouve la valeur uneVal parmi les nbElt
données du tableau tab; retourve Vrai si trouvé, et faux sinon. }
Paramètres tab : tableau [1, MAX] de entiers
nbElt, uneVal : entiers
ind : entier
variables trouvé : booléen
début

Fonction ajout(tab, nbElt, uneVal) retourne booléen
{Ajoute la valeur uneVal au tableau tab de nb éléments. retourne vrai si
Possible, sinon faux}
nbElt : entier
uneVal : entier
variable possible : booléen
début

Exemple de traitements avec plusieurs tableaux
Algorithme copieTableau
{Recopie un tableau dans un autre tableau en changeant le signe des valeurs }
constante (MAX : entier) Å 100
variables nbV, ind : entier ;
tab1, tab2 : tableau [1, MAX] de réels
début
{remplissage du tableau tab1}
saisieTableau(tab1, nbV, ok)
{vérification de la saisie} …
pour ind ← 1 à nbV faire
tab2 [ind] ← - tab1 [ind]
fpour
{suite du traitement}
…
fin
Comparaison de deux tableaux
Algorithme CompareTableaux
{Vérifie l'identité de deux tableaux}
constante (MAX : entier) Å 100
variables nbV1, nbV2, ind : entiers
égaux, mêmeNbVal, ok : booléens
tab1, tab2 : tableau [1, MAX] de réels
début

saisieTableau(tab1, nbV1, ok)

saisieTableau(tab2, nbV2, ok)

(Comparaison de deux tableaux, suite)
{Traitement : comparaison des deux tableaux}
mêmeNbVal ← nbV1 = nbV2
Si mêmeNbVal
alors {parcours en parallèle tant qu’on ne trouve pas une différence}
fsi
{Affichage résultats}

Retour au tableau à deux dimensions
10 3 25 14 2 1 8
9 20 7 12 2 4 7
constantes MAXLigne ..., MAXColonne ...
type T2D = tableau[1,MAXLigne ; 1,MAXColonne]

d’entiers
variable monTab : T2D

Quelques procédures
associées au type T2D
Procédure initTab2D(val, tab)
{affecte la valeur val à tous les éléments du tableau 2 dim Tab}
paramètres (D) val : entier
(R) tab : T2D
variables
début
Simulation :

(Définitions, suite)
Procédure saisirTab2DavecDim(tab, nbrL, nbrC)

{effectue la saisie d’un tableau 2 dim à nbrL lignes et nbrC colonnes}
paramètres (R) tab : T2D
(D) nbrL, nbrC : entiers
variables
début
Simulation :

Procédure afficherTab2D(tab, nbrL, nbrC)
{affiche toutes les valeurs d’un tableau 2 dim à nbrL lignes et nbrC colonnes}
paramètres (D) tab : T2D
variables
début
Procédure copierTab2D(tabSource, tabDest, nbrL, nbrC)

{copie toutes les valeurs de tabSource dans tabDest; ces deux tableaux sont
superposables}
paramètres (D) tabSource : T2D
(R) tabDest : T2D
variables
début

Fonction rechercheVal(val, tab, nbrL, nbrC, numL, numC) retourne booléen

{recherche les coordonnées numL et numC de la valeur val dans un tableau
2 dim; retourne VRAI si trouvé, FAUX sinon}
paramètres (D) val, nbrL, nbrC : entiers
(D) tab : T2D
(R) numL, numC : entiers

Algorithme Exemple
{Traitements sur un tableau à deux dimensions.}
variables monTab : T2D
nbrL, nbrC, uneVal, ind : entiers
trouvé : booléen
début
afficher(«Entrez le nombre de lignes ( ≤ » , MAXLignes, « ) »)
saisir(nbrL)
afficher(«Entrez le nombre de colonnes ( ≤ » , MAXColonnes, « ) »)
saisir(nbrC)
{saisies supposées correctes}
saisirTab2DavecDim(monTab, nbrL, nbrC)
afficherTab2D(monTab, nbrL, nbrC)
afficher(«Quelle valeur voulez vous rechercher ?»)
saisir(uneVal)
trouvé Å rechercheVal(uneVal, monTab, nbrL, nbrC, numL, numC)
si trouvé
alors afficher(uneVal, « se trouve à la ligne », numL,
« et à la colonne », numC)
sinon afficher(uneVal « ne se trouve pas dans le tableau. »)
fin
Modularité :
Méthodologie d'analyse d'un problème

en langage algorithmique
Algorithmique 2 : Modularité 73
Problème : écrire l'algorithme du jeu de Saute Mouton
Sur une ligne de NB cases, on place, à la suite et en partant de la gauche, des pions
noirs puis des pions rouges séparés par une case vide unique. On pose autant de
pions noirs que de pions rouges. La configuration de pions n'occupe pas
nécessairement toute la ligne.
But du jeu :
Déplacer tous les pions rouges vers la gauche (respectivement tous les pions noirs
vers la droite), la case vide occupant à la fin du jeu la case du milieu de la
configuration comme au départ.
Exemple :
configuration initiale : configuration finale gagnante :
N N N N R R R R R R R R N N N N
1 2 3 4 5 6 7 8 9 10
Règles du jeu:
- les pions noirs ne peuvent se déplacer que vers la droite
les pions rouges ne peuvent se déplacer que vers la gauche
- un pion noir peut être déplacé à droite dans la case vide :
- si la case vide est juste à droite de ce pion
- s'il lui suffit de sauter par dessus un seul pion rouge, c'est-à-dire si entre la case
vide et lui il n'y a qu'un seul pion rouge.
- un pion rouge peut être déplacé à gauche dans la case vide :
- si la case vide est juste à gauche de ce pion
- s'il lui suffit de sauter par dessus un seul pion noir, c'est-à-dire si entre la case
vide et lui il n'y a qu'un seul pion noir.
Exemple : coups possibles : coups interdits :
N R N R R
N R R N R N
Fonctionnement :
• A vous de jouer en donnant simplement la position du pion que vous jouez.
• La machine déplace le pion choisi si c'est possible.
• Le jeu s’arrête si vous avez gagné ou si vous avez atteint une situation de blocage.
Dans ce cas vous avez perdu!
Comment lire un énoncé de problème

dans le but d'écrire l'algorithme correspondant
Æ repérer les données proposées
Æ repérer les résultats attendus
Æ identifier les contraintes de la tâche
Æ définir les traitements à réaliser
• Structure de données :
Dans un premier temps, se demander quelles structure de
données utiliser pour la représentation interne des données
- le plateau de jeu Æ Plateau: tableau de caractères
constante (NbMAX : entier) Å 10 {nombre max de pions d'une couleur}
type Plateau = tableau [1, 2 x NbMAX + 1] de caractères
variable jeu : Plateau
• Contraintes du jeu
Puis : bien comprendre les contraintes du jeu en explicitant les
règles de façon plus formelle; inventorier les situations possibles.
si pion-rouge
alors si case-gauche est vide
alors déplacement-gauche
sinon si case-gauche-noire et case-suivante est vide
alors déplacement-saut-gauche
sinon si pion-noir
alors si case-à-droite est vide
alors déplacement-droite
sinon si case-droite-rouge et case-suivante est vide
alors déplacement-saut-droite
Déplacement ≈ échange de valeurs entre la case vide et la case du pion à jouer.

• Hiérarchie des appels de sous-algorithmes
Puis : reformuler l'énoncé en tentant de planifier le travail,
"décortiquer" les étapes successives du jeu.
Î décomposer la tâche en sous-tâches

Algorithme schématique
- initialiser le plateau de jeu
- afficher le plateau de jeu
- jouer un coup (si coup proposé est permis)
- rejouer si non fini
- si fini, proposer de refaire une partie
Î concevoir la hiérarchie des appels de sous-algorithmes
Algo principal
initPlateau affichePlateau jouerUnCoup finJeu? rejouer?
nbPionsCorrect? pionJouable? coupPermis?
bloqué? gagné?
permisRouge? permisNoir?
• Écriture de l'algorithme principal
(Une possibilité parmi d’autres)
Algorithme SauteMouton
{jeu de saute mouton}
constante (NbMAX : entier) Å 10 {nombre maximum de pions d'une couleur}
type Plateau = tableau [1, 2 x NbMAX + 1] de caractères
variables plateauJeu : Plateau
nbPions : entier {nombre de pions d'une couleur}
indVide : entier {indice de la case vide}
suite : booléen {vrai si partie non terminée}
début
répéter initPlateau(plateauJeu,nbPions)
affichePlateau(plateauJeu,nbPions)
suite Å non finJeu?(plateauJeu,nbPions,indVide)
tant que suite faire
jouerUnCoup(plateauJeu,nbPions,indVide)
affichePlateau(plateauJeu,nbPions)
suite Å non finJeu?(plateauJeu,nbPions,indVide)
ftq
tant que rejouer?
fin Algorithmique 2 : Modularité 81
• Spécification des sous-algorithmes
exemple:
Procédure initPlateau(tab,nb)
{demande le nombre nb de pions rouges à utiliser et vérifie que ce nombre est
acceptable. Si oui, remplit le plateau tab de nb pions rouges et nb pions noirs,
sinon demande un nouveau nombre.}
paramètres (R) tab : plateau
(R) nb : entier
• Définition des sous-algorithmes

• Programmation
Attention !!!
Rien n'est figé, à tout moment on peut être
amené à modifier des choix faits précédemment.
Comment faciliter la mise au point
d'un programme
• donnez des noms évocateurs à vos variables, à vos constantes, à vos sous-
algorithmes
• programmez modulairement : chaque bloc de l'algorithme remplit un sous-but
élémentaire du problème général
• documentez votre travail : identifiez chaque bloc par un commentaire
explicatif
• truffez l'algorithme d'affichages permettant de suivre à la trace l'exécution du
programme correspondant
• mettez au point module par module votre programme, en construisant des
jeux d'essais appropriés à chacun de ces modules
• prévoyez un affichage de contrôle des valeurs saisies aussitôt après la saisie
Des habitudes qu'il est vivement conseillé de prendre !

Construction d'un jeu d'essais pour la
validation d'un algorithme
Î explorer tous les cheminements possibles à l'intérieur d'un

algorithme
construction à partir de la modélisation informatique
Î inventorier tous les "cas de figure" des données soumises

prendre en compte :
- un cas général (ou plusieurs distingués)
- les cas extrêmes ("effets de bord")
construction à partir de la théorie
fin Volume 2
Algorithmique : Volume 2 85

Cours Algo 1 2

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

Cours Algo 1 2

Transféré par

Droits d'auteur :

Formats disponibles

Université Paris XI

iUT ORSAY I.U.T. d'Orsay

Cécile Balkanski, Nelly Bensimon, Gérard Ligozat

• Objectif : obtenir de la «machine» qu’elle effectue

Mais... comment le lui dire ?

• résoudre des problèmes «comme» une

• Apprentissage d’un langage

Briques de LEGO Camion de pompiers

Laine Pull irlandais

Farine, oeufs, chocolat, etc.... Forêt noire

Un algorithme, traduit dans un langage compréhensible par l’ordinateur

• L’écriture algorithmique : un travail de

variables unNombre, sonCarré: entiers {déclarations: réservation

Algorithmique 1 : Instructions de base 10

variable <liste d’identificateurs> : type

Algorithmique 1 : Instructions de base 11

saisir(<liste de noms de variables>)

Algorithmique 1 : Instructions de base 13

constante (<identificateur> : type) ← <expression>

début {préparation du traitement}

afficher(Titre) {présentation du résultat}

Algorithmique 1 : Instructions de base 17

Algorithmique 1 : Instructions de base 18

début {préparation du traitement}

• Déclarer une variable supplémentaire

• Utiliser cette variable pour stocker provisoirement

Algorithmique 1 : Instructions de base 20

Algorithmique 1 : Instructions de base 21

Si l’expression logique (la condition) prend la valeur vrai,

Algorithmique 1 : Instructions de base 23

Algorithmique 1 : Instructions de base 24

S’il y a plus de deux choix possibles, l’instruction selon

Algorithmique 1 : Instructions de base 25

Comparer : si abréviation = "M"

Algorithmique 1 : Instructions de base 28

pour <var> ← valInit à valfin [par <pas>] faire

Algorithmique 1 : Instructions de base 29

pour <variable> ← <valeur à <valeur par <valeur faire

Algorithmique 1 : Instructions de base 30

• Implicitement, l’instruction pour:

pour cpt Å 1 à MAX faire

Algorithmique 1 : Instructions de base 31

Algorithmique 1 : Instructions de base 33

amorçage {initialisation de la (des) variable(s) de condition}

Algorithmique 1 : Instructions de base 35

• Implicitement, l’instruction pour:

Algorithmique 1 : Instructions de base 37

si le nombre d’itérations est connu à l’avance,

si la boucle doit s'arrêter quand survient un

Algorithmique 1 : Instructions de base 38

Algorithmique 1 : Instructions de base 40

Boucle tant que

Algorithmique 1 : Instructions de base 44

fsi, ftq et fpour peuvent être omis si le corps

Algorithmique 1 : Instructions de base 45

tant que A faire B

saisir des données

saisir des données

Algorithmique 1 : Instructions de base 48

Algorithmique 1 : Instructions de base 49

Algorithmique 1 : Instructions de base 50

• Structure itérative "universelle"

• Structure itérative irremplaçable dès que la