Algorithme

NIVEAU 2 | Initiation des programmes I

HINT
 Plan du cours

1.Introduction

2.Instructions de base

3.Logique propositionnelle
HINT
 Pourquoi un algorithme?
Objectif : Obtenir de la machine qu’elle effectue
un travail à notre place

Problème : expliquer à la machine comment elle

doit s’y prendre.
 Comment le lui dire?
 Comment le lui apprendre?
 Comment sassurer qu’elle fait ce travail aussi bien
que nous
 Mieux que nous?
HINT
 Objectifs pour ce cours
Résoudre des problèmes comme une machine

Savoir expliciter son raisonnement

Savoir formaliser son raisonnement

Concevoir (et ecrire) des algorithmes

HINT
 Thèmes abordés en « Algo »
Apprentissage d’un langage

Notions de base
 Algorithmes de bases pour problèmes élémentaires

Structure de données
 Des plus simples aux plus complexes

Résolution de problèmes complexes

 Algorithmes astucieux et efficaces
HINT
 Vous pratiquez tous les jours les
« algos »

Brique de LEGO Camion de pompier

Suite de dessins

Meuble en Kit Cuisine Equipée

Notice de montage

Cafetière Expresso
Instructions
Farine, œufs, Gâteau au chocolat
chocolat, etc …
Recette
HINT
 De façon générale
Séquence d’instructions qui décrit comment
résoudre un problème particulier.

Un algo utilise des Variables pour manipuler :

• Des données en entrée
• Des données auxiliaires
• Des résultats à mettre en sortie

HINT
 Importance de l ’algorithme

Informations Résultats mise

éparses en forme

Machine

Données Obtention
structurées des résultats

TRAITEMENT
HINT
 Importance de l’algorithme (2)
Un algo, traduit dans un langage compréhensible par un ordinateur
(ou langage de programmation), donne un programme, qui peut
ensuite être exécuté, pour effectuer le traitement souhaité

Les programmes sont traduient en un autre

langage proche de la machine par un
programme nommé Compilateur

Les programmes peuvent être interprétés ligne

par ligne et exécutés. Le programme qui
s’occupe de cela est : Interpréteur
HINT
 Importance de l’algorithme (3)
Savoir expliquer comment faire un travail sans la
moindre ambiguité
• Langage simple: des instructions (pas élémentaires)
• Suite finie d’actions à entreprendre en respectant une
chronologie

L’écriture algorithme : un travail de

programmation à visée universelle
Un algorithme ne dépend pas :
Du langage il est ipmplanté
Ni de la machine qui exécutera le programme
correspondant HINT
 Problèmes fondamentaux
Complexité
• En combien de temps un algorithme va-t-il attendre le
résultat escompté?
• De quel espace a-t-il besoin ?
Calculabilité
• Existe-t-il des tâches pour lesquels il n’existe pas
d’algorithme
• Etant donné une tâche, peut-on dire s’il existe un
algo qui la résolve
Correction
• Peut-on être sûr qu’un algrithme réponde au
problème pour lequel il ea été conçu? HINT
2. Instruction de base

HINT
 Premier algorithme
Algorithme ElèveAuCarré
{Cet algorithme calcule le carré du nombre que lui fournit l'utilisateur}

Variable unNombre, sonCarré: entier {déclarations:

réservation d'espace-mémoire}
Début

{préparation du traitement}
ecrire("Quel nombre voulez-vous élever au carré?")
lire(unNombre)

{traitement : calcul du carré}

sonCarré ← unNombre×unNombre

{présentation du résultat}
ecrire("Le carré de ", unNombre)
ecrire("c'est ", sonCarré)

fin
HINT
 Parties d’un Algo
Titre de l’algo
• Précédé par le mot clé : Algorithme

Déclarations de variables ou de constantes

Corps de l’algo
• Commençant par un mot-clé : début
• Finissant par un mot-clé: fin

HINT
 Trois étapes de conception
Préparation du traitement
• Données nécessaires à la réalisation du problème

Traitement
• Résolution pas àpas, après décomposition en sous-
problèmes si nécessaire

Edition ou renvoie des résultats

• Impression dans un fichier, à l’écran, etc…

HINT
 Déclaration d’une variable
Variable <liste des 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)

Exemple
Variable val, unNombre : entier
nom, prenom : chaine de caractères

HINT
 Lire une donnée
lire (<liste des noms de variables>)
Fonction
• Instruction permettant de placer en memoire les
informations fournir par l’utilisateur

Exemple
Lire (val)
Lire (prenom, nom)
Lire (unNombre)

HINT
Afficher une donnée, un résultat
ecrire (<liste des noms de variables, de
constantes ou d’expressions>)

Fonction
• Instruction permettant de visualiser les information
placées en mémoire.

Exemple
ecrire (unNombre, “est differrent de 0”)
ecrire (“la somme de ”, unNombre,” et “, val, “vaut:”,
unNombre + val)
HINT
 Déclaration d’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.

Exemple
Constante (MAX: entier) 255
(DOUBLEMAX: entier) MAX*2
HINT
 Lire et ecrire : exemple
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}
ecrire("Donnez-moi le prix hors taxe :")
lire(prixHT)

prixTTC ← prixHT*(1+TVA/100){calcul du prix TTC}

ecrire(Titre){présentation du résultat}
ecrire(prixHT, «eurosH.T. devient ", prixTTC,
«eurosT.T.C.")
Fin
Affichage:??? HINT
 Affecter 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
Val= ??
HINT
 Affectation: exemple
Constante (SEUIL : réel) ←13.25
Variable valA, valB: réel
compteur : entier
mot , tom : chaînes valA = ??
valA ← 0.56
valB = ??
valB ← valA
Compteur =??
valA ← valA*(10.5 + SEUIL)
Compteur ← 1
Mot = ??
Mot ← " bonjour " Tom = ??
Tom ← " Au revoir! « 
Compteur ← compteur + 10
HINT
 Simulation d’un algorithme
Algorithme CaFaitQuoi?
{Cet algorithme ……………………………………}
Variables valA, valB: réels {déclarations}

début{préparation du traitement}
ecrire("Donnez-moi deux valeurs :")
lire(valA, valB)
ecrire("Vous m’avez donné",valA, "et", valB)

valA ← valB
valB ← valA

ecrire(« Maintenant, mes données sont", valA,"et",

valB)
Fin
Affichage:???
HINT
 Traitement à faire si …
On veut saisitr un entier, et afficher son double
si cet entier dépasse un seuil dans le cas
contraire, on l’affiche.

Est-ce-possible avec ce qu’on vient de voir?

HINT
 Insctruction conditionnelle
si <expression logique>
alors instructions
[sinon instructions]
fsi

Fonction
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).
HINT
 Instruction conditionnelle (2)
Algorithme SimpleOuDouble
{Cet algorithme saisit un entier et affiche son double si il
dépasse un certain seuil}
constantes(SEUIL : entier) ←10
Variables val: entier {déclarations}

début{préparation du traitement}
ecrire("Donnez-moi un entier :")
lire(val)

Si val < SEUIL

alors val ← val*2
fsi

ecrire("Voici la valeur finale" , val)

Fin
HINT
 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 ecrire ("Reçu avec Mention")
sinon si note > 10
alors ecrire ("Passable")
sinon ecrire ("Insuffisant")
fsi

fsi
HINT
 Selection sur le choix multiple
selon <identificateur>
(liste de) valeur(s) : instructions

(liste de) valeur(s) : instructions

…
[autres: instructions]
fselon
Fonction
Si il y’a plus de deux choix possibles pour une variable,
l’instruction selon permet de faciliter l’écriture.

HINT
 Instruction selon : exemple
selon abréviation
"M" :afficher( " Monsieur " )
"Mme" :afficher( " Madame " )
"Mlle" : afficher( " Mademoiselle " )
autres :afficher( " Monsieur, Madame " )
Fselon

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
HINT
 Quand faut-il repéter un traitement..

On voudrait sommer plusieurs valeurs que

l’utilisateur lit.

Est-ce-possible avec ce qu’on vient de voir?

HINT
 La boucle Pour
pour <var> ←valInit à valfin [par <pas>] faire
traitement {suite d’instructions}
fpour

Fonction
Repéter une suite d’instruction un certains nombres de
fois: |(valFin –valInit):pas| + 1

HINT
 La boucle Pour: exemple
Algorithme FaitTotal
{somme les nbVal données tapés par l’utilisateur}
Variables nbVal, cpt : entiers
valeur, total: réels {déclarations}

début{préparation du traitement}
ecrire("Combien de valeurs voulez-vous saisir")
lire(nbval)
Total ← 0
Pour cpt ← 1 à nbVal faire
ecrire ("Donnez une valeur")
lire (valeur)
total ← total + valeur
fPour
ecrire("le total des", nbVal, "vaut" , total)
Fin
HINT
 Semantique de la boucle Pour

Implicitement, l’instruction :
• Initialise la variable de boucle
• Incrémente cette variable à chaque pas
• Vérifie que cette variable ne dépasse pas la borne

Attention
• Le traitement de la boucle ne doit pas modifier la
variable de boucle

HINT
Quand le nombre d’itération n’est pas
connu
On voudrait sommer plusieurs valeurs que
l’utilisateur lit mais on ne connait pas le nombre
exact.

Est-ce-possible avec ce qu’on vient de voir?

HINT
 La boucle Tant que
amorçage {initialisation de la (des) variable(s) de condition}
tant que <expression logique (vraie)> faire
traitement {suite d’instructions}
relance {ré-affectation de la (des) variable(s) de condition}
ftq

Fonction
Repéter une suite d’instruction tant qu’une condition est
remplie
Remarque : si la condition est fause dès le départ, le
traitement n’est jamais exécuté
HINT
 La boucle Tant que: exemple
Algorithme FaitTotalAvecTantQue
{somme les nbVal données tapés par l’utilisateur, arrêt à -1}
Constante (STOP : entier) ← -1
Variables valeur, total: réels {déclarations}

début{préparation du traitement}
Total ← 0
ecrire("Donnez une valeur.",STOP, "pour finir ")
lire(valeur)
Tant que valeur ≠ STOP faire
total ← total + valeur
ecrire ("Donnez une valeur.",STOP, "pour finir ")
lire (valeur)
fTq
ecrire(" la somme des valeurs saisis :", total)
Fin
HINT
 Semantique de la boucle Pour
Amorçage : initialisation
de la variable de
condition
Condition
d’exécution du
lire(valeur) traitement
Tant que valeur ≠ STOP faire
total ← total + valeur
ecrire ("Donnez une valeur.",STOP, "pour finir ")
lire (valeur)
fTq
afficher("La somme des valeurs saisies est",traitement
totalValeurs)
à
exécuter si la
relance: condition est
ré-affectation vérifiée
affichage:
des
résultats
de la variable
de condition HINT
 Comparaison entre Pour et Tant que
Pour cpt ← 1 à nbVal faire
ecrire ("Donnez une valeur")
lire (valeur)
total ← total + valeur
fPour

… équivaut à
Cpt ← 0
Tant que cpt < nbVal faire
ecrire ("Donnez une valeur")
lire (valeur)
total ← total + valeur
cpt ← cpt + 1 {compte le nombre de valeurs traitées}
fTq
HINT
Comparaison entre Pour et Tantque (2)

Implicitement, l’instruction :
• Initialise un compteur
• Incrémente le compteur à chaque pas
• Vérifie que cette variable ne dépasse pas la borne
supérieure

Explicitement, l’instruction tant que doit:

• Initialise un compteur {amorçage}
• Incrémente le compteur à chaque pas {relance}
• Vérifie que le compteur ne dépasse pas la borne
supérieure {test de boucle}
HINT
Choisir Pour… Choisir Tant que

Si le nombre d’itération est connu:

• Choisir la boucle POUR

Si la boucle doit s’arrêter quand survient un

élément:
• Choisir la boucle TANT QUE

HINT
La boucle « répéter…tant que »
repeter
ré-affectation de la (des) variable(s) de condition
traitement {suite d’instructions}
Tant que <expression logique (vraie)>

Fonction
Exécuter une suite d’instruction au moins une fois et la
repé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
HINT
 La boucle Repéter: exemple
Algorithme ValeurStrictementPositive
{affiche une valeur non nulle}
Variables valeur: entier {déclarations}

début{préparation du traitement}

Repeter
ecrire ("Donnez une valeur positive non nulle")
lire (valeur)
Tant que valeur < 0

ecrire(" La valeur positive saisie est:", valeur)

Fin

HINT
 Comparaison Tant que et Repeter
Repeter
ecrire ("Donnez une valeur positive paire")
lire (valeur)
Tant que (valeur <0 ou (valeur%2) ≠ 0)

… équivaut à
ecrire ("Donnez une valeur positive paire")
lire (valeur)
Tant que (valeur <0 ou (valeur%2) ≠ 0) faire
ecrire ("Donnez une valeur positive paire")
lire (valeur)
fTq
HINT
 Comparaison Tantque et repeter (2)

Boucle Tant que:

• Condition avant chaque exécution du traitement
• Le traitament peut donc ne pas être exécuter
• De plus, la condition porte surtout sur la saisie de
nouvelles variables (relance)
Boucle Repeter…Tant que:
• Condition vérifiée après chaque exécution 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 HINT
 Choisir Pour…Tant que… Répéter
BOUCLE TANT QUE
O N
Traitement N
exécuté au
moins une OU
fois ? I

N
NO
Nombre BOUCLE REPETER
d’itération
s connu ?
OUI

BOUCLE POUR

HINT
Le problème d’une boucle: il faut en sortir

Tant que A faire B

Repeter B tant que A

Quelque chose dans la suite d’intructions B

doit amener A à prendre la valeur “Faux”

• Suite d’instruction B doit modifier au moins une

variable de l’expression logique A
• C’est l’expression logique A et elle seule qui en
prenant la valeur “Faux” provoque l’arrêt de la boucle
HINT
 De l’énoncé à la boucle
afficher le carré des saisir(val)
valeurs saisies tant tant que val ≠0 faire
qu’on ne saisit pas 0 ecrire(val×val)
lire(val)
ftq

lire(val)
saisir des données et somme ←val
s'arrêter dès que leur tant que somme ≤ 500 faire
somme dépasse 500 lire(val)
somme ← somme + val
ftq HINT
Quand utilisez la boucle Tantque?
Structure itérative “universelle”
• N’importe quelle structure itérative peut se traduire
par la boucle 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 saisie 5 données.

HINT
De l’importance du test de sortie de boucle
(… et donc de la logique)

tant que val ≠STOP et nbVal< MAX faire

Dans la boucle : val ≠STOP et nbVal< MAX est

vrai
À la sortie de la boucle
• Soit val ≠STOP est faux et donc val =STOP
• Soit nbVal< MAX est faux et donc nbVal > MAX

Que tester à la sortie de la boucle

• Si val = STOP alors {Traitement1}
• Si nbVal > MAX alors {Traitement2} HINT