(N7-3EA) (Cours Raffinage Algo) (2020-2021) (ETU)

Département EEEA - 1 ère année
UE N5EE02A –
Algorithmique et
Programmation Impérative
-
Du raffinage à l’algorithme
Département EEEA 1ère année 1

Objectif de l’enseignement
Pré-requis:
Aucun en particulier, sinon avoir déjà interagi avec un ordinateur au cours de sa vie…
Objectifs:
L'objectif de cette matière consiste à appréhender les différentes notions liées à la

conception et à la réalisation d'un projet informatique en Langage C. Les cours
introduisent les règles et l'importance du raffinage, de la conception algorithmique,
ainsi que les principes élémentaires liés à la pratique du Langage C.
En appui de ces enseignements théoriques, une large part est donnée aux aspects
pratiques avec un bureau d'étude. Il permettra d'illustrer de manière pratique
l'ensemble des notions vues en cours, du son raffinage jusqu’a l'organisation
algorithmique du projet, jusqu’à son implantation et son utilisation sur un calculateur.

Les objectifs …
 Etre capable de développer et programmer une application informatique

répondant à un cahier des charges
Analyse
Programme
spécification conception Compilation
codage exécution
Problème
besoin
Cahier des charges
Algorithmique et
méthode de raffinage Langage C
COURS
COURS
Algorithmique et
méthode de raffinage
COURS

Organisation et découpage de l’enseignement
 Cours / TD
 1 ( 1,75h) Cours : Présentation Algorithmique et Méthode de raffinage

 1 ( 1,75h) TD en salle sans machine ( Présentiel )
 BE : 8 séances
 3 Séances découverte Langage C

 5 Séances Projet - Simulation d’un circuit électrique
 Evaluation
 EXAMEN INDIVIDUEL ECRIT : 1h ( cours Raffinage / Algorithmique )
 1 RAPPORT de BE par binôme : Rapport Simulateur Circuit RL

Qu’est ce qu’un algorithme … Petits rappels ?
La réalisation d’un programme informatique passe systématiquement

par une étape de conception préliminaire : l’algorithme du programme
 Un algorithme est une suite d’opérations ou d’instructions permettant de

résoudre un problème
 Dans le domaine informatique, un algorithme est INDEPENDANT du

langage dans lequel il sera par la suite programmé. Il est compréhensible
par quelqu’un qui ne sait pas faire de code informatique
 L’algorithme doit permettre au programmeur d’avoir tous les éléments

nécessaires pour réaliser le codage dans le langage choisi
 Pour décrire un algorithme, plusieurs formalismes de représentation

peuvent être utilisés : le pseudo-code ou l’ organigramme. Ces modes de
représentation sont équivalents.

Qu’est ce qu’un algorithme ?
 Exemple : Algorithme pour un diabolo ( menthe ou fraise )
Pseudo-code Organigramme
Début
Prendre un verre
Prendre un verre
Fraise
Si CHOIX menthe Choix
Alors Mettre du sirop de menthe Menthe

Mettre du sirop Mettre du sirop
Sinon Si CHOIX fraise de fraise de menthe
Alors Mettre du sirop de fraise
FinSi Mettre de la
limonade
Mettre de la limonade
Mettre un glaçon Mettre un
glaçon
Fin

Comment concevoir
un algorithme ?
ETAPE 1 : Lecture du cahier des charges et Raffinage
ETAPE 2 : Construction de l’algorithme

ETAPE 1 – Lecture du cahier des charges et raffinage : être clair sur les objectifs
 L’objectif est, dès le départ du projet, d’avoir une idée la plus précise possible de la demande
afin d’éviter les malentendus de conception
 Le raffinage permet de détailler le cahier des charges afin d’avoir une idée précise de la
réalisation avant de commencer la conception de l’algorithme et sa programmation

ETAPE 1 - Un peu de vocabulaire pour commencer
Qu’est-ce qu’un Processeur

 Elément capable d’exécuter des actions élémentaires
 Exemples de processeur
Humain Robot Machine Ordinateur

Un processeur peut être plus ou moins complexe, c’est-à-dire qu’il est capable de
d’exécuter des instructions plus ou moins complexes
Qu’est ce qu’une action élémentaire ?

Action associée a un processeur. Il la comprend et est capable de l’exécuter
Qu’est qu’une donnée ?

Ce que devra manipuler le processeur

Etape 1 - Principe du raffinage
 Pour aider un concepteur à concevoir un algorithme, nous proposons de suivre une

démarche à étapes successives permettant d’aider à obtenir une solution en
réponse à un cahier des charges.
1 Il faut exprimer l’action principale R0 que l’on veut réaliser et avec quel
processeur on souhaite le faire
2 Il faut identifier les principales données manipulées. Des données

supplémentaires pourront être rajoutées plus tard
3 Il faut ensuite décomposer l’action principale à l’aide d’actions plus

simples notées Ri
Tant que l’on considère que les actions sont trop complexes
pour être comprise par le processeur, la décomposition
continue par ajout de niveaux ( R1, R2, R3,…)
c’est le processus de raffinage

Etapes 1 - Méthode de raffinage … Exemple
 Reprenons l’exemple de la préparation d’un diabolo menthe

Données
Verre
1 Processeur : Humain 2 Sirop de menthe
Glaçon
Limonade
Version Ecrite R0 : Préparer un diabolo menthe

Niveau 0
R1 : Raffinage de {Préparer un diabolo menthe}
| Prendre un verre
| Mettre du sirop dans le verre Niveau 1
Trop complexe | Mettre de la limonade dans le verre
donc raffinage
| Mettre un glaçon dans le verre
3
Version Arbre
R0 : Préparer un diabolo menthe Niveau 0
R1 : Prendre un R1 : Mettre de la R1 : Mettre du sirop R1 : Mettre un

verre limonade dans le verre dans le verre glaçon dans le verre Niveau 1

Etape 1 - Méthode de raffinage … Exemple
Version Ecrite R0 : Préparer un diabolo menthe

Niveau 0
R1 : Raffinage de {Préparer un diabolo menthe}
| Prendre un verre
| Mettre de la limonade dans le verre
Niveau 1
Trop complexe | Mettre du sirop dans le verre
donc raffinage | Mettre un glaçon dans le verre
R2 : Raffinage de {Mettre de la limonade dans le verre}

| Ouvrir le frigo
| Prendre la limonade Niveau 2
| Verser la limonade dans le verre
| Remettre la limonade au frigo
| Fermer le frigo
Version Arbre
R0 : Préparer un diabolo menthe Niveau 0
R1 : Prendre un R1 : Mettre de la R1 : Mettre du R1 : Mettre un Niveau 1

verre limonade dans le verre sirop dans le verre glaçon dans le verre
R2 : Verser la R2 : Remettre
R2 : Ouvrir le R2 : Prendre la R2 : Fermer le
frigo limonade
limonade dans le limonade au
frigo
Niveau 2
verre frigo

Etape 1 - Méthode de raffinage
 Le critère d’arrêt de la décomposition dépend du problème et de l’expérience du

concepteur. Il s’agit en général d’obtenir des sous-actions correspondant à des
actions élémentaires facilement réalisables par un processeur
R0 : Action Principale
R1 : A1 R1 : A2 Niveau 0
R2 - A1 R2 - A2 R2 - A3 R2 - A4 Niveau 1
R3-A1 R3-A2 R3-A3 R3-A4

Niveau 2
Actions réalisables
par le processeur

Etape 1 - Méthode de raffinage … Exemples à 2 Niveaux
Version Ecrite
R0 : Action Principale Niveau 0
R1 : Raffinage de {Action Principale}

| Action R1-A1 Niveau 1
| Action R1-A2
R2 : Raffinage de {Action R1-A1}

| Action R2-A1
| Action R2-A2
Niveau 2
| Action R2-A3
| Action R2-A4
Version Arbre
R0 - Action Principale Niveau 0
R1 - A1 R1 - A2 Niveau 1
R2 - A1 R2 - A2 R2 - A3 R2 - A4 Niveau 2

Etape 1 - Méthode de raffinage … Exemples à 3 Niveaux
Version Ecrite Version Arbre

Niveau 1 R0 : Action Principale
| Action R1-A2

| Action R2-A1 R1 - A1 R1 - A2 Niveau 1
Niveau 2
| Action R2-A2
R2 : Raffinage de {Action R1-A2} R2 - A1 R2 - A2 R2 - A3 R2 - A4 Niveau 2

| Action R2-A3
Niveau 2
| Action R2-A4
R3-A1 R3-A2 R3-A3 R3-A4 Niveau 3
| Action R3-A2

| Action R3-A3

Etape 1 : Méthode de raffinage
 On va souvent avoir besoin d’inclure dans le raffinage des structures de

contrôle qui permettent de faire des tests et des répétitions d’actions
Structures de contrôle
• Si … Alors … FinSi
• Si … Alors … Sinon … FinSi
• Selon … dans …Sinon … FinSelon
• Tant que … Faire … FinTQ
• Faire … tant que …
• Répéter … jusqu’à …
• Pour … jusqu’à … FinPour
• …

Etape 1 : Méthode de raffinage … Exemple avec structures de contrôle
 Exemple 1
Version Ecrite

| Si Réponse vaut 1
| Alors Faire R1-Action 1
| Sinon Faire R1-Action 2
| FinSi
Version Arbre
OUI NON Niveau 1

Réponse =1 ?
R1 - Action 1 R1 - Action 2

Etape 1 : Méthode de raffinage … Exemple avec structures de contrôle
 Exemple 2
Version Ecrite

| Tant que Réponse différente de 1
| Faire R1-Action 1
| FinTQ
| R1-Action 2
Version Arbre
OUI NON
Réponse Niveau 1
R1 - Action 1 différent de 1 R1 - Action 2

Etape 1 : Méthode de raffinages … Exemple avec structures de contrôle
 Reprenons l’exemple de la préparation d’un diabolo mais avec une petite variante. Le
diabolo peut maintenant être à la fraise ou à la menthe
Données
Verre
Processeur : Humain Sirop de menthe
Sirop de fraise
Glaçon
Version Ecrite
R0 : Préparer un diabolo Limonade
R1 : Raffinage de {Préparer un diabolo}

| Prendre un verre
| Mettre du sirop dans le verre
| Mettre un glaçon dans le verre
R2 : Raffinage de {Mettre du sirop dans le verre}

| Si Choix Menthe
| Alors Mettre du sirop de menthe
| Sinon Si Choix Fraise
| Alors Mettre du sirop de fraise
| FinSi

Etape 1 : Méthode de raffinages … Exemple avec structures de contrôle
Données
Verre
Sirop de menthe
Sirop de fraise
Processeur : Humain
Glaçon
Version Arbre Limonade

R0 : Préparer un diabolo Fraise
ou Menthe
R1 : Prendre un R1 : Mettre du sirop R1 : Mettre de la R1 : Mettre un

verre dans le verre limonade dans le verre glaçon dans le verre
Menthe R2 : Mettre du
Choix
sirop de menthe
Fraise
R2 : Mettre du sirop de
fraise

Exercice sur le raffinage
Exemple 1

Etape 1 : Exemple par raffinage du déplacement d’un robot
 Exemple : Déplacement d’un robot

Zone B
Zone A

 Action Principale R0 : Aller de la Zone A à la Zone B en récupérant le boulon

Données
 Processeur : Robot Zone A
 Données Zone B
Boulon
 Action élémentaires : Le processeur peut
• Avancer d’une case

• Tourner à droite
• Tourner à gauche
• Prendre un objet
Rappels : l’analyse consiste à se poser la question suivante :
 Est-ce que le processeur ( le robot ) est en mesure d’exécuter l’action

principale (R0) ?
Ici NON, car le processeur ne sait faire que 4 actions
 DEBUT DU RAFFINAGE

 A ce stade, il est impossible de décrire directement les actions de Niveau 0 avec les actions
élémentaires. On utilise donc des étapes intermédiaires :
Version Ecrite
R0 : Aller de la zone A à la zone B en récupérant le boulon
R1 : Raffinage de {Aller de la zone A à la zone B en récupérant le boulon}

| Aller de la zone A au boulon Raffinage Niveau 1
| Prendre le boulon
| Aller du boulon à la zone B
Version Arbre
R0 : Fonction Principale :
Aller de la Zone A à la Zone B en récupérant le boulon
Niveau 0
R1 : Aller de la zone A au R1 : Aller du boulon a la Niveau 1

R1 : Prendre le boulon
boulon zone B

Version Ecrite

| Aller de la zone A au boulon
| Prendre le boulon
 Est-ce que le processeur ( le robot ) est en mesure d’exécuter les actions de

niveau 1 ?
NON pas toutes.
Le processeur ne sait faire que 4 actions : Avancer d’un pas, Tourner à droite,
Tourner à gauche, Prendre un objet
Il sait juste exécuter R1 : Prendre le boulon
 Le processus de raffinage continue

Version Ecrite R0 : Aller de la zone A à la zone B en récupérant le boulon

| Prendre le boulon
R2 : Raffinage de {Aller de la zone A au boulon}

| Avancer de 3 cases Raffinage Niveau 2
| Tourner à droite
R2 : Raffinage de {Aller du boulon à la zone B}
| Avancer de 2 cases Raffinage Niveau 2
| Tourner à gauche
| Avancer de 2 cases
Version Arbre
R0 Fonction Principale :
Niveau 0 Aller de la Zone A à la Zone B en récupérant le boulon
R1: Aller de la zone A au R1 : Aller du boulon a la

Niveau 1 boulon
zone B
R2 : Avancer de 3 R2 : Tourner à R2 : Avancer de R2 : Tourner à R2 : Avancer

Niveau 2 cases droite 2 cases gauche de 2 cases

Exemple du déplacement d’un robot
Version Ecrite R0 : Aller de la zone A à la zone B en récupérant le boulon

| Prendre le boulon

| Tourner à droite

| Tourner à gauche
 Est-ce que le processeur ( le robot ) est en mesure d’exécuter les actions de niveau 2 ?
NON pas toutes.

Le processeur ne sait faire que 4 actions : Avancer d’un pas, Tourner à droite, Tourner à
gauche, Prendre un objet
Il sait juste exécuter R2 : Tourner à droite et R2 : Tourner à gauche
 Le processus de raffinage continue

Version Ecrite

| Prendre le boulon

| Tourner à droite

| Tourner à gauche
R3 : Raffinage de {Avancer de 3 cases} Raffinage Niveau 3

| Avancer d’une case

Version Arbre
R0 Fonction Principale :
Niveau 0
Aller de la Zone A à la Zone B en récupérant le boulon
Niveau 1 R1: Aller de la zone A au R1 : Aller du boulon a la

boulon zone B
R2 : Avancer de 3 R2 : Tourner à R2 : Avancer de R2 : Tourner à R2 : Avancer

cases droite 2 cases gauche de 2 cases
Niveau 2
R3 : Avancer R3 : Avancer R3 : Avancer R3 : Avancer R3 : Avancer R3 : Avancer R3 : Avancer

de 1 case de 1 case de 1 case de 1 case de 1 case de 1 case de 1 case
Niveau 3

 Est-ce que le processeur ( le robot ) est en mesure d’exécuter les actions

de niveau 3 ?
Version Ecrite

| Prendre le boulon

| Tourner à droite

| Tourner à gauche


Ici OUI
Le processus de raffinage est terminé

Exercice sur le raffinage
Exemple 2

Exemple 2 : Méthode de raffinage pour préparation d’un thé
 Prenons maintenant l’exemple de la préparation d’un thé par un être humain .

C’est le niveau R0 de la décomposition.
 Processeur : Humain Données
 Données Eau
Thé
Tasse
Bouilloire
 Si les actions élémentaires sont mal connues au départ, le processus de

raffinage va permettre d’aider à les déterminer. Le concepteur pourra ainsi
stopper le raffinage quand il jugera les actions suffisamment élémentaires.
 Actions élémentaires : Pas claires à ce stade
 Considérons la fonction à réaliser trop complexe pour être réalisée par le

processeur ( ici l’être humain) . Il faut commencer par mettre en place le
processus de raffinage

 Il faut commencer à imaginer le raffinage en sous-actions plus simples. Des actions

élémentaires viennent alors à l’esprit telles que : Faire bouillir de l’eau, Mettre le thé dans
la tasse, Ajouter l’eau dans la tasse
Version Ecrite
R0 : Préparation d’un thé
R1 : Raffinage de {Préparation d’un thé}

| Faire bouillir de l’eau
| Mettre le thé dans la tasse
| Ajouter l’eau dans la tasse
Version Arbre
R1 : Mettre le thé/café R1 : Ajouter l’eau dans la

R1 : Faire bouillir de l’eau
dans la tasse tasse

 Bien évidemment, ces sous-actions de Niveau 1 peuvent être à nouveau décomposées

pour obtenir des fonctionnalités encore plus simples si l’on considère que le processeur ne
pourra pas les réaliser facilement.
Version Ecrite

| Faire bouillir de l’eau Trop complexe : raffinage
R2 : Raffinage de {Faire bouillir de l’eau}

| Remplir la bouilloire
| Contrôler la température de l’eau
 On peut poursuivre le raffinage en considérant que Contrôler la température de

l’eau est encore trop complexe.

 On procède au raffinage de Contrôler la température de l’eau
Version Ecrite

Trop complexe : raffinage
| Contrôler la température de l’eau
R3 : Raffinage de {Contrôler la température de l’eau}

| Démarrer la bouilloire
| Mesurer la température de l’eau
| Arrêter la bouilloire
 On peut poursuivre le raffinage en considérant que Vérifier la température de l’eau

est encore trop complexe.

Version Arbre
R0 : Préparation d’un thé Niveau 0
R1 : Faire bouillir de l’eau … … Niveau 1
R2 : Contrôler la
R2 : Remplir la bouilloire Niveau 2
température de l’eau
R3 : Démarrer la R3 : Mesurer la R3 : Arrêter la

Niveau 3
bouilloire température de l’eau bouilloire

Version Ecrite


| Contrôler le température de l’eau
R3 : Raffinage de {Contrôler la température de l’eau}

| Démarrer la bouilloire
| Vérifier la température de l’eau Trop complexe : raffinage
| Arrêter la bouilloire
R4 : Raffinage de {Vérifiez la température de l’eau }

|FAIRE Mesurer Température de l’eau
|TANT QUE Température < 100°C
|FINTQ

Exemple 3 : Méthode de raffinage pour préparation d’une boisson chaude
 Complexification : On veut pouvoir préparer des cafés – noisettes et des thés au lait
Le raffinage va par contre faire apparaitre de nouvelles actions et des nouvelles données
 Données :
R0 : Préparation d’une boisson
Données Niveau 0
chaude
Eau
Thé
Café Choix
?
Bouilloire
Lait Café
Choix
Café-noisette Thé Thé au lait
R1 : Préparer un R1 : Préparer un R1 : Préparer un R1 : Préparer un

Niveau 1
café café-noisette thé thé au lait
R2 : Faire bouillir de R2 : Mettre le thé R2 : Mettre l’eau dans

l’eau dans la tasse la tasse Niveau 2

 Chaque sous-action peut maintenant être décomposée en niveaux inférieurs. Par exemple,
pour la préparation d’un café noisette, on obtient :
R0 : Préparation d’une boisson chaude
Choix ? Niveau 0
R1 : Préparer R1 : Préparer un Niveau 1

un café café-noisette
Niveau 2
R2 : Faire bouillir R2 : Faire chauffer R2 : Mettre le lait R2 : Mettre le café R2 : Mettre l’eau dans
de l’eau le lait dans la tasse dans la tasse la tasse
 La méthode de raffinage permet de faire apparaitre des actions communes qui pourront
être ré-utilisées ( Faire bouillir de l’eau et Mettre l’eau dans la tasse existent déjà dans le
raffinnage précédent ) .
 On perçoit déjà à ce stade l’intérêt que cela va présenter par la suite en terme d’organisation
pour la phase de programmation

 Si l’on déroule la méthode de raffinage pour cet exemple, une solution peut être :
R0 : Préparation d’une Niveau 0

boisson chaude
Choix ?
Niveau 1
R1 : Préparer un R1 : Préparer un thé
R1 : Préparer un café R1 : Préparer un thé
café-noisette au lait
R2 : Faire bouillir de R2 : Faire bouillir de R2 : Faire bouillir de R2 : Faire chauffer le

l’eau l’eau l’eau lait
R2 : Mettre le café R2 : Faire chauffer le R2 : Mettre le thé R2 : Faire bouillir de

dans la tasse lait dans la tasse l’eau
R2 : Mettre l’eau dans R2 : Mettre le café dans R2 : Mettre l’eau dans R2 : Mettre le thé
la tasse la tasse la tasse dans la tasse
Niveau 2 R2 : Mettre le lait dans Niveau 2 R2 : Mettre le lait

la tasse dans la tasse
R2 : Mettre l’eau dans la R2 : Mettre l’eau dans

Niveau 2 tasse Niveau 2 la tasse

Méthode de raffinage : Exercice
A vous de jouer …


Ce week-end, vous recevez de la famille dans votre appartement
Le cahier des charges est donc d’accueillir

dignement vos invités dans un appartement
propre , rangé ET de leur préparer un repas
Données
- Aspirateur
- Serpillière
 Le processeur, c’est vous - Seau
-…
 Actions élémentaires :
pas clairs à ce stade …
On va dire que vous avez 3 endroits à gérer : Salon (dans lequel vous dormez ) ,
Salle de Bain+WC, Coin cuisine

Version Ecrite
R0 : Accueillir dignement vos invités dans un appartement propre et faire à manger
R1 : Raffinage de {Accueillir dignement vos invités dans un appartement propre et

préparer un repas}
| Nettoyer Appartement
| Préparer un repas
R2 : Raffinage de {Nettoyer Appartement}
R2 : Raffinage de {Préparer un repas}
Version Ecrite
R0 : Accueillir dignement vos invités dans un appartement propre et

Niveau 0
rangé
R1 : Ranger R1 : Préparer repas Niveau 1
Niveau 2

Méthode de raffinage … Un exemple de solution
R0 : Accueillir dignement vos invités dans un appartement propre et faire à manger
R1 : Raffinage de {Accueillir dignement vos invités dans un appartement propre et préparer un repas}
| Nettoyer Appartement
| Préparer un repas
R3 : Raffinage de {Cuisiner le repas}
R2 : Raffinage de {Nettoyer Appartement} | Préparer les ingrédients
| Nettoyer Salon | Réaliser la recette
| Nettoyer Salle de bain | Réserver le plat pour le repas
| Nettoyer Cuisine
R2 : Raffinage de {Préparer un repas} R4 : Raffinage de {Passez la serpillère}

| Trouver une idée de menu | Sortir le seau
| Aller faire des courses | Remplir le seau d’eau chaude
| Cuisiner le repas | Mettre du produit nettoyant dans le seau
| Mettre la table | Laver le sol avec la serpillère
| Rincer la serpillère
R3 : Raffinage de {Nettoyer Salon}
| Ramasser mes habits qui trainent par terre
| Jeter les boites de pizza vides
| Replier mon clic-clac On peut raffiner aussi loin que l’on désire les différentes
| Passer la serpillère actions mais le raffinage systématique des niveaux n’est pas
obligatoire si les actions associées sont suffisamment claires
R3 : Raffinage de {Nettoyer le salle de bain} ( Trouver une idée Menu et mettre la table par exemple n’ont
| Nettoyer le lavabo pas été raffinés !!!!
| Nettoyer les WC et la douche
| Passer la serpillère
C’est au concepteur d’apprécier la ou il arrête sa démarche
R3 : Raffinage de {Nettoyer Cuisine} de raffinage
| Nettoyer le frigo
| Nettoyer la plaque de cuisson tout grasse Un raffinage n’est jamais unique car il existe plusieurs
| Passer la serpillère solutions pour arriver au même résultat !!!!!

Exercices d’applications - Exercice 1 : Calcul de moyenne
 EXERCICE 1 : Donner le raffinage d’un programme informatique capable de

calculer la moyenne de 2 nombres. Les 2 nombres seront saisis au clavier par
l’utilisateur. La valeur de la moyenne des 2 nombres sera ensuite affichée sur un
écran

Exercices d’applications - Exercice 1 : Calcul de moyenne - Correction
R0 : Calculer la moyenne de 2 nombres
R1 : Raffinage de {Calculer la moyenne de 2 nombres}
| Saisir les 2 nombres

| Calculer la moyenne
| Afficher le résultat
R2 : Raffinage de {Saisir les 2 nombres}

| Demander valeur du nombre 1
| Demander valeur de nombre 2
R2 : Raffinage de {Calculer la moyenne}

| moyenne = ( nombre 1 + nombre 2) / 2
R2 : Raffinage de {Afficher le résultat}

| Afficher " La moyenne des nombres vaut " moyenne
R3 : Raffinage de {Demander valeur du nombre 1 }

| Ecrire "entrer la valeur du nombre 1"
| Lire nombre 1
R3 : Raffinage de {Demander valeur du nombre 2}

| Lire nombre 2

Exercices d’applications - Exercice 2 : Calcul de coefficient directeur
 EXERCICE 2 : Donner le raffinage d’un programme informatique capable de

calculer le coefficient directeur d’une droite à partir de la connaissance de 2
points A et B de cette droite. Les coordonnées des points A et B doivent être
saisies au clavier par l’utilisateur.

Exercices d’applications - Exercice 2 : Calcul de coefficient directeur - Correction
R0 : Calculer le coefficient directeur d’une droite
R1 : Raffinage de {Calculer le coefficient directeur d’une droite}
| Saisir les points A et B

| Calculer le coefficient directeur
R2 : Raffinage de {Saisir les points A et B}

| Demander valeur de x pour point A
| Demander valeur de y pour point A
| Demander valeur de x pour point B
| Demander valeur de y pour point B
R2 : Raffinage de {Calculer le coefficient directeur}

| pente = ( yB – yA ) / (xB - xA)

| Afficher « la pente d’une droite passant par A et B vaut » pente
R3 : Raffinage de {Demander valeur de x pour point A}

| Ecrire "entrer la valeur de x pour point A"
| Lire xA pour point A
R3 : Raffinage de {Demander valeur de y pour point A}

| Ecrire "entrer la valeur de y pour point A"
| Lire yA pour point A
R3 : Raffinage de {Demander valeur de x pour point B}

| idem
R3 : Raffinage de {Demander valeur de Y pour point B}

| idem

Exercices d’applications - Exercice 3 : Faire deviner un nombre
 EXERCICE 3 : Donner le raffinage d’un programme informatique d’un jeu

permettant de faire deviner à un joueur un nombre compris entre 0 et 10 en 3
coups. Le nombre à deviner sera saisi au clavier par l’utilisateur au départ du jeu.
A chaque tour de jeu, le programme demande au jouer sa proposition et doit
indiquer à l’utilisateur si le nombre proposé est plus grand ou plus petit que le
nombre à deviner

Exercices d’applications - Exercice 3 : Faire deviner un nombre - Correction
R0 : Faire deviner un nombre entre 0 et 10 en 3 essais
R1 : Raffinage de {Faire deviner un nombre entre 0 et 10 en 3 essais}

| Saisir le nombre à deviner
| Faire
| Jouer un tour
| Tant que nombre proposé est faux et qu’il reste des coups
R2 : Raffinage de {Saisir le nombre à deviner}

Amélioration
| Ecrire " Entrer le nombre à deviner " Faire
| Lire le nombre à deviner Ecrire " Entrer votre nombre "
Lire nombre
| Effacer écran
Si nombre < 0 ou nombre > 10
Afficher " Le nombre doit être compris entre 0 et 10 "
R2 : Raffinage de {Jouer un tour} Fin Si
| Entrer une proposition de nombre Tant que nombre < 0 ou nombre > 10
| Incrémenter le nombre de coup Retourner nombre
| Contrôle de la proposition
R3 : Raffinage de {Entrer une proposition de nombre}

| Ecrire " Proposer un nombre "
| Lire le nombre proposé
R3 : Raffinage de {Contrôle de la proposition}

| Si nombre proposé = nombre à deviner
| Alors Afficher " Gagné !! Bien joué "
| nombre proposé est vrai
| Sinon Si nombre proposé > nombre à deviner
| Alors Afficher " Le nombre est plus petit "
| Sinon Afficher " Le nombre est plus grand "
| nombre proposé est faux
| FinSi

Comment concevoir
un algorithme ?
ETAPE 1 : Lecture du cahier des charges et Raffinage
ETAPE 2 : Construction de l’algorithme

Etape 2 : Construction de l’algorithme
L’algorithme est pris en main par un programmeur qui va

Rappel de
le traduire directement à l’aide d’un langage de
l’objectif programmation
 Le raffinage obtenu permet de construire l’algorithme, soit en pseudo-code, soit sous

forme d’organigramme
 La construction de l’algorithme « de niveau N » consiste à traduire le raffinage de niveau N

en séquences d’instructions.
 Dans l’algorithme, la CHRONOLOGIE des instructions est très importante car elle définit
l’ordre dans lequel seront exécutées les différentes actions par le processeur
 Les données seront transformées en constantes ou en variables dont on devra préciser la

nature ( entier, réel, caractère, … )
 Les variables devront bien sûr être manipulables par le processeur qui devra exécuter le
programme

 Traduction en pseudo-code : Algorithme à partir du raffinage Niveau 2
On écrit l’algorithme en utilisant les actions identifiées à partir du raffinage de Niveau 2 .

Dans cet exemple, le niveau 2 est le plus haut niveau de raffinage. Ces actions sont
directement exécutables par le processeur
Algorithme en Pseudo Code

N’apparait
Raffinage pas dans Variables : …
R0 : Action Principale l’algorithme
Début Algorithme
| Action R1-A1 Action R2-A1
Action R2-A3
| Action R2-A2
Fin Algorithme
| Action R2-A3
| Action R2-A4

 Traduction en organigramme : Algorithme à partir du raffinage Niveau 2
Algorithme en organigramme
Raffinage Variables : … Début
R1 : Raffinage de {Action Principale} Action R2-A1

| Action R1-A1
| Action R1-A2
N’apparait Action R2-A2
R2 : Raffinage de {Action R1-A1} pas dans
| Action R2-A1 l’algorithme
R2 : Raffinage de {Action R1-A2} Action R2-A4

| Action R2-A3
| Action R2-A4
Fin

 Traduction en pseudo-code : Algorithme à partir du raffinage Niveau 2
Raffinage Si le niveau de raffinage n’est pas le même pour

R0 - Action Principale
toutes les actions, attention de ne pas oublier
dans la construction de l’algorithme de faire
R1 - A1 R1 - A2 apparaître les actions de niveau inférieur
Pas de
raffinage de Algorithme en Pseudo Code
Niveau 2 pour
R2 - A3 R2 - A4
R1-A1
Variables : …
Raffinage
R0 : Action Principale Début Algorithme

Action R1-A1
| Action R1-A1
| Action R1-A2 Pas de raffinage Action R2-A3
| Action R2-A3
| Action R2-A4 Fin Algorithme

Etape 2 : Construction de l’algorithme … Préparation d’un diabolo
 Reprenons l’exemple de la préparation d’un diabolo à partir du résultat

du raffinage
Algorithme Niveau 2
Variables : verre, sirop de fraise, sirop de

menthe, glaçon, limonade, choix
Version Ecrite
Début Algorithme
R0 : Préparer un diabolo Prendre un verre
R1 : Raffinage de {Préparer un diabolo} Demander choix

| Prendre un verre Pas de raffinage Si choix Menthe
| Mettre du sirop dans le verre Alors Mettre du sirop de menthe dans verre
| Mettre de la limonade dans le verre Pas de raffinage Sinon Si choix Fraise
| Mettre un glaçon dans le verre Pas de raffinage
Alors Mettre du sirop de fraise dans verre
R2 : Raffinage de {Mettre du sirop dans le verre} FinSi
| Si Choix Menthe
| Alors Mettre du sirop de menthe Mettre de la limonade dans le verre
| Alors Mettre du sirop de fraise Mettre un glaçon dans le verre
| FinSi
Fin Algorithme

Etape 2 : Construction de l’algorithme … Préparation d’un diabolo
Algorithme en Organigramme
Variables : verre, sirop de Début

fraise, sirop de menthe,
glaçon, limonade, choix
Prendre un verre
Raffinage
Demander choix
R0 : Préparer un diabolo Fraise

Choix
R1 : Raffinage de {Préparer un diabolo}
| Prendre un verre
| Mettre du sirop dans le verre Menthe
| Mettre un glaçon dans le verre Mettre du sirop Mettre du sirop
de fraise de menthe
R2 : Raffinage de {Mettre du sirop dans le verre}
| Si Choix menthe
| Alors Mettre du sirop de menthe
| Alors Mettre du sirop de fraise Mettre de la limonade
| FinSi
Mettre un glaçon
Fin

Etape 2 : Construction de l’algorithme … Notion de sous-Programme
 L’algorithme complet peut parfois être fastidieux à écrire. On fait donc apparaître la notion de sous-
programme (SP). Le sous-programme est une instruction algorithmique qui regroupe plusieurs autres
instructions.
 Les sous-programmes sont facilement identifiables grâce au raffinage Algorithme du SP R1-A1
 Traduction en pseudo-code : Algorithme - Niveau 1 Variables : …

Début Algorithme
Action R2-A1
R1 - A1 R1 - A2 Action R2-A2
Algorithme Niveau 1
Variables : … Fin Algorithme

R2 - A1 R2 - A2 R2 - A3 R2 - A4
Début Algorithme
SP qui inclue R2-A1 et R2-A2
SP Action R1-A1
SP Action R1-A2 SP qui inclue R2-A3 et R2-A4
R1 : Raffinage de {Action Principale} Algorithme du SP R1-A2
| Action R1-A1
| Action R1-A2 Fin Algorithme Variables : …
R2 : Raffinage de {Action R1-A1} Début Algorithme
| Action R2-A1
| Action R2-A3 Algorithme
| Action R2-A4 Fin Algorithme
complet
Etape 2 : Construction de l’algorithme … Notion de sous-Programme
 Traduction en organigramme : Algorithme - Niveau 1

Algorithme du SP R1-A1
Début
Action R2-A1
R1 - A1 R1 - A2 Algorithme du Niveau 1
Action R2-A2
R2 - A1 R2 - A2 R2 - A3 R2 - A4 Début
Fin
R0 : Action Principale Action R1-A1
| Action R1-A2
Algorithme du SP R1-A1
R2 : Raffinage de {Action R1-A1} Fin

| Action R2-A1
Début
| Action R2-A2

| Action R2-A3
| Action R2-A4
Action R2-A4
Fin

Etape 2 : Construction de l’algorithme … Règles pour les sous-programmes
 Il existe 2 types de sous-programmes
- Les sous-programmes qui ne renvoient aucune donnée vers l’appelant : ils sont
appelés PROCEDURES.
- Les sous-programmes qui renvoient une UNIQUE donnée vers l’appelant : ils
sont appelés FONCTIONS. Ces sous-programmes se comportent comme une
fonction mathématique y=f(x). Il faut alors utiliser le mot clef retourne pour
spécifier quelle donnée doit être renvoyée au programme appelant
 Si un sous-programme doit renvoyer plusieurs données, l’utilisation de la

FONCTION est impossible. La FONCTION ne sait renvoyer qu’une seule valeur.
Il faudra alors utiliser une PROCEDURE qui aura des droits particuliers pour
pouvoir modifier les données qui lui seront transmises. Elle ne renvoie rien
mais elle permet de modifier des données à l’intérieur du sous-programme
Quels sont ces droits ?

Etape 2 : Construction de l’algorithme … Règles sur les données
 Les sous-programmes comportent des variables. Ces variables sont :
 soit locales au sous-programme, c’est-à-dire que lui seul les connait et les utilise
 soit proviennent de l’extérieur, c’est-à-dire que ce sont des variables transmises au
sous-programme. On parle aussi d’arguments du sous-programme.
 Un sous-programme qui reçoit des variables de l’extérieur possède 3 modes d’accès à ces
variables :
 Soit le sous-programme peut seulement lire la variable mais pas la modifier. La

variable est alors de type entrée seulement ( type IN )
 Soit le sous-programme peut lire ET modifier la variable. La variable est alors de type
entrée-sortie ( type IN / OUT)
 Soit le sous-programme ne peut que modifier la variable. La variable est alors de type
sortie ( type OUT)
 Ainsi, de manière générale, on choisit pour un sous-programme une FONCTION quand il

n’y a qu'une valeur à retourner à l’appelant (OUT) et que la variables d’entrée du sous-
programme sont en lecture seulement ( IN )
 On choisit pour un sous-programme une PROCEDURE quand il n’y a rien à retourner à

l’appelant OU que l’on souhaite que la PROCEDURE modifie une ou plusieurs des
variables transmises. Elles devront alors être de type ( IN / OUT ).

Etape 2 : Construction de l’algorithme … Définition d’un sous-programme
 Pour rassembler toutes les informations relatives à un sous-programme, il faut

donner sa définition. La définition d’un sous-programme comporte
l’algorithme et les spécifications. Ces dernières permettent de préciser un
certain nombre d’informations nécessaires au codage et à la vérification du
fonctionnement du sous-programme.
 Dans les spécifications, Il faut tout d’abord définir le rôle du sous-programme (
quelle fonction va-t-il réaliser ) , son type ( FONCTION ou PROCEDURE), les
variables qu’il manipule , ainsi que leurs natures et leurs sens de circulation.
 Toujours dans les spécifications Il faut ensuite donner le contrat que l’algorithme
doit respecter, c’est-à-dire les pré-conditions et post-conditions qui sont
associées à son utilisation.
 Enfin, les spécifications du sous-programme doivent comporter également un ou

des exemples de test permettant de vérifier, après codage et à partir d’entrées
spécifiées, quelle doit être la réponse de l’algorithme.
 Une fois les spécifications établies, on peut donner l’algorithme qui décrit
précisément comment est réalisée la tâche assurée par le sous-programme

Etape 2 : Construction de l’algorithme … Définition complète d’un sous-programme
 Pour résumer, la définition complète du sous-programme se présente donc ainsi :

=================================================================
 Nom : Nom du sous-programme et type ( FONCTION ou PROCEDURE )
Rôle et variables
 Sémantique: Décrire ce que réalise sous-programme
Définition complète du sous-programme

 Paramètres:
Spécifications
Param_1 : Mode d’accès (IN, OUT, IN/OUT ) ; Type ; Rôle du paramètre
…
Param_n2 : Mode d’accès (IN, OUT, IN/OUT ) ; Type ; Rôle du paramètre
 Pré-condition : Conditions sur les paramètres en entrée
Contrat
 Post-condition : Conditions sur les paramètres en sortie
Tests
================================================================
 Test : si les entrées sont … alors l’algorithme doit répondre …
================================================================
Algorithme
[ FONCTION ou PROCEDURE ] [ Nom du sous-programme ] [ Arguments du SP]
Début
...
Fin
Exemple 1 : FONCTION
 Exemple pour un sous-programme qui calcul le prix d’un article en

réduction
 Il reçoit un prix et une réduction. Pas besoin de modifier ces variables donc accès en entrée
(IN)
 Il retourne une seule valeur ( OUT ) qui correspond au prix avec la réduction  C’est une
FONCTION
 Ecriture de la spécification du sous-programme

====================================================================================
Rôle et variables
Nom : FONCTION CALCUL PRIX
Sémantique: calcul le prix d’un article avec réduction
Paramètres:
prix (IN) - réel - prix de l’article sans réduction
Spécifications
reduction (IN) - réel - valeur de la réduction en %
prix final (OUT) - réel - prix avec réduction
Contrat
Pré-condition : prix > 0 et 0 < reduction en % < 100 doivent être initialisés
Post-condition : aucune
=====================================================================================
Tests
Test : prix = 100 ; réduction = 20 ; prix_final = 80 ;
=====================================================================================

 Ecriture del’algorithme
============================================================================
Nom : FONCTION CALCUL PRIX
Sémantique: calcul le prix d’un article avec réduction
Paramètres:
Spécifications

prix (IN) ; réel ; prix de l’article sans réduction
reduction (IN) ; réel ; valeur de la réduction en %
prix_final (OUT) ; réel ; prix avec réduction
Pré-condition : prix > 0 et 0 < reduction < 100 doivent être initialisés
===========================================================================
Test : prix = 100 ; réduction = 20 ; prix_final = 80 ;
===========================================================================
FONCTION CALCUL PRIX ( prix, reduction (IN) : réel ) retourne réel prix_final
variables prix_final :réel
Algorithme
Début Algorithme
prix_final = prix*(1-reduction/100)
retourner prix_final
Fin Algorithme

 Appel du sous-programme
Algorithme Programme Principal
Variables : p,red,pred : réel

Début Algorithme
p=85.5
red=20 Appel du SP
retour du SP
pred = CALCUL PRIX (p,red)
p
prix final Fin Algorithme red
Algorithme du SP CALCUL PRIX
FONCTION CALCUL PRIX ( prix (IN) , reduction (IN) réel ) retourne réel prix final
variables prix_final :réel

prix et reduction en lecture seulement (IN)
Début Algorithme
prix_final = prix*(1-reduction/100)
retourner prix final
retour de prix final
Fin Algorithme

Exemple 2 : PROCEDURE avec variables en lecture (IN)
 Exemple pour un sous-programme qui reçoit deux variables de type entier val1 et val2
qu’il doit afficher
 Pas besoin de modifier les variables donc accès en entrée seulement (IN)
 Pas de retour de données vers le programme principale : le sous-programme
est une PROCEDURE
==================================================================================================
Nom : PROCEDURE AFFICHE PARAMETRE
Sémantique: affiche à l’écran les valeurs des 2 paramètres transmis au sous-programme
Spécifications
Paramètres:
val1 (IN) ; entier ; paramètres N°1 à afficher
Pré-condition : val1 et val2 doivent être initialisés
==================================================================================================
Test : val1 = 20 ; val2 = 5 ; La programme affiche : La valeur 1 vaut 20 , La valeur 2 vaut 5
===================================================================================================

 Ecriture de l’algorithme
==================================================================================================
Nom : PROCEDURE AFFICHE PARAMETRE
Sémantique: affiche à l’écran les valeurs des 2 paramètres transmis au sous-programme
Spécifications

Paramètres:
Pré-condition : val1 et val2 doivent être initialisés
==================================================================================================
Test : val1 = 20 ; val2 = 5 ; La programme affiche : La valeur 1 vaut 20 , La valeur 2 vaut 5
===================================================================================================
PROCEDURE AFFICHE PARAMETRES : val1 (IN) ,val2 (IN) : entier
Algorithme
Début Algorithme
Afficher "La valeur 1 vaut" , val1

Fin Algorithme

Algorithme
Variables : A,B : entier

Début Algorithme
A=1
B=2
AFFICHE PARAMETRES (A,B) val1 et val2 en lecture seulement
A=1
(IN)
Fin Algorithme B=2
Algorithme du SP Afficher
PROCEDURE AFFICHE PARAMETRES : val1 (IN) ,val2 (IN) : entier
Début Algorithme
Aucun retour
Fin Algorithme

Exemple 3 : PROCEDURE avec variables en lecture / écriture (IN / OUT)
 Exemple pour un sous-programme qui reçoit deux variables val1 et val2 qu’il doit
modifier avec 2 nouvelles valeurs newVal1 et newVal2
 Besoin de modifier les variables donc accès en entrée / sortie (IN /OUT)
 Pas de retour de données vers le programme principale : le sous-programme

est une PROCEDURE

====================================================================================
Nom : PROCEDURE MODIFIER PARAMETRES
Sémantique: modifie la valeur des 2 paramètres transmis au sous-programme
Paramètres:
val1 (IN / OUT) - entier - paramètres N°1 à modifier
Spécifications
newVal1 (IN) - entier - nouvelle valeur du paramètres N°1
Pré-condition : aucune
Post-condition : newVal1 et newVal2 doivent impérativement contenir une valeur
=====================================================================================
Test : val1 = x, val2 = x, newVal1 = 5, newVal2 = 3 ; Réponse : val1 = 5, val2 = 3 ;
=====================================================================================

 Ecriture de l’algorithme
====================================================================================
Nom : PROCEDURE MODIFIER PARAMETRES
Sémantique: modifie la valeur des 2 paramètres transmis au sous-programme

Paramètres:
Spécifications
Pré-condition : aucune
Post-condition : newVal1 et newVal2 doivent impérativement contenir une valeur
=====================================================================================
Test : val1 = x, val2 = x, newVal1 = 5, newVal2 = 3 ; Réponse : val1 = 5, val2 = 3 ;
=====================================================================================
PROCEDURE MODIFIER PARAMETRES ( val1,val2 (IN/OUT), newVal1, newVal2 (IN) : entier )
Début Algorithme
Algorithme
val1 = newVal1
Val2 = newVal2
Fin Algorithme

Algorithme
Variables : v1,v2,newv1,newv2 : entiers

Début Algorithme
v1=1
v2=2
newv1 = 3 v1=1
newv2 = 4 v2=2
MODIFIER PARAMETRES (v1,v2,newv1,newv2) newv1 = 3
newv2 = 4
Fin Algorithme
Algorithme du SP MODIFIER PARAMETRES
PROCEDURE MODIFIER PARAMETRES (val1 , val2 (IN/OUT) , newVal1, newVal2 (IN) : entier )
v1=3 Début Algorithme
v2=4
val1 = newVal1
v1 et v2 du
programme Val2 = newVal2
Précise que les variables sont en
principale entrée/sortie (IN / OUT) donc
modifiés Fin Algorithme
modifiables par le sous-programme

A vous de jouer …
Exercices et Corrections

Correction des exercices
Rappel : Pour toute procédure / fonction on écrit la définition complète du sous-programme qui comporte le rubriques suivantes
=================================================================
 Nom : Nom du sous-programme et type ( FONCTION ou PROCEDURE )
Rôle et variables
 Sémantique: Décrire ce que réalise sous-programme

 Paramètres:
Spécifications
Param_1 : Mode d’accès (IN, OUT, IN/OUT ) ; Type ; Rôle du paramètre
…
Param_n2 : Mode d’accès (IN, OUT, IN/OUT ) ; Type ; Rôle du paramètre
 Pré-condition : Conditions sur les paramètres en entrée
Contrat
 Post-condition : Conditions sur les paramètres en sortie
Tests
================================================================
 Test : si les entrées sont … alors l’algorithme doit répondre …
================================================================
Algorithme
[ FONCTION ou PROCEDURE ] [ Nom du sous-programme ] [ Arguments du SP]
Début
...
Fin
Exercices d’applications
Dans ces exercices, le raffinage de l’application est déjà réalisé. Il s’agit donc de se
concentrer sur la traduction en algorithmique des raffinages fournis.
 EXERCICE 1 : Vous devez concevoir une application capable de calculer la

moyenne de 2 nombres. Le raffinage est donné. Dans un premier temps, donner
la définition du programme principale sans faire aucun sous-programme. Dans
un second temps, vous ferez une version avec sous-programme pour les sous-
programmes qui vous sont demandés.
 EXERCICE 2 : Vous devez concevoir une application capable de calculer le

coefficient directeur d’une droite. Le raffinage est donné. Dans un premier temps,
donner la définition du programme principale sans faire aucun sous-
programme. Dans un second temps, vous ferez une version avec sous-
programme pour les sous-programmes qui vous sont demandés.
 EXERCICE 3 : Vous devez concevoir un jeu permettant de faire deviner à un

joueur un nombre compris entre 0 et 10 en 3 coups. Le raffinage est donné.
Donner les définitions des sous-programmes identifiés et du programme
principal.

Exercice 1 : Algorithme de calcul de moyenne
R0 : Calculer la moyenne de 2 nombres
R1 : Raffinage de {Calculer la moyenne de 2 nombres}
| Saisir les 2 nombres

| Calculer la moyenne
Raffinage donné
R2 : Raffinage de {Saisir les 2 nombres} Sous

| Demander valeur du nombre 1 programme
| Demander valeur de nombre 2 demandé
R3 : Raffinage de {Demander valeur de A}

| Lire nombre 1
R3 : Raffinage de {Demander valeur de B}

| Lire nombre 2

Exercice 1 : Algorithme de moyenne – Solution sans sous-programme
Algorithme du programme principal sans sous-programme
=====================================================================
Nom : Algorithme de moyenne
Sémantique : Programme principal
Paramètres :
n1 - réels - premier nombre à moyenner
n2 - réels - second nombre à moyenner
moy - réels - valeur de la moyenne
Pré-condition : Aucune
Post-condition : La moyenne des 2 nombres est affichée
=====================================================================
Test : n1 = 15.5 , n2 = 41.3 – résultat : moy = 28.4
=====================================================================
Variables : n1,n2,moy : réels
Début Algorithme
Ecrire "Entrer la valeur du nombre 1"

Lire n1
Ecrire "Entrer la valeur de n2"
Lire n2
m = (n1+n2) / 2
Ecrire "La moyenne vaut :" , moy
Fin Algorithme

Exercice 1 : Algorithme de moyenne – Solution avec sous-programme
Algorithme SP Saisie_Nombres
========================================================
Nom : PROCEDURE Saisie_Nombres
Sémantique: Assure la saisie des 2 nombres à moyenner
Spécifications
Paramètres:
n1 (IN/OUT) - réel – premier nombre à saisir
n2 (IN/OUT) - réel – second nombre à saisir
pré-condition : Aucune
post-condition : n1 et n2 doivent comporter des valeurs
========================================================
Test : Saisir n1=15.5 , n2 = 41.3 . De retour dans le programme
principale afficher les valeurs qui doivent être correctes
========================================================
PROCEDURE Saisie_Nombres : n1 , n2 (IN/OUT) : réel

Algorithme Programme Principal
Début Algorithme
Algorithme
=================================
Ecrire "Entrer la valeur du nombre 1 " …
Lire n1 ================================
Ecrire "Entrer la valeur du nombre 2 " Variables : n1, n2,moy : réels
Lire n2
Début Algorithme
Fin Algorithme
Saisie_Nombres ( n1,n2 )
moy = (n1+n2) / 2
Ecrire "La moyenne vaut :" , moy
Fin Algorithme

Exercice 2 : Algorithme de calcul de coefficient directeur
R0 : Calculer le coefficient directeur d’une droite
R1 : Raffinage de {Calculer le coefficient directeur d’une droite}
| Saisir les points A et B

| Calculer le coefficient directeur
R2 : Raffinage de {Saisir les points}

| Demander valeur de x pour point A Sous
| Demander valeur de y pour point A programme
Raffinage donné
| Demander valeur de x pour point B demandé

| Demander valeur de y pour point B
R2 : Raffinage de {Calculer le coefficient directeur}

| pente = ( yB – yA ) / (xB - xA)

| Afficher « la pente d’une droite passant par A et B vaut pente »
R3 : Raffinage de {Demander valeur de x pour point A}

| Ecrire "entrer la valeur de x pour point A"
| Lire xA pour point A
R3 : Raffinage de {Demander valeur de y pour point A}

| Ecrire "entrer la valeur de y pour point A"
| Lire yA pour point A
R3 : Raffinage de {Demander valeur de x pour point B}

| idem
R3 : Raffinage de {Demander valeur de Y pour point B}

| idem

Exercice 2 : Algorithme de calcul de coefficient directeur – Solution sans sous-programme
Algorithme du Programme Principal sans sous-programme

=====================================================================
Nom : Algorithme de calcul de coefficient directeur
Paramètres :
xA - réel – Coordonnée xA
yA - réel – Coordonnée yA
xB - réel – Coordonnée xB
yB - réel – Coordonnée yB
c - réel – valeur du coefficient directeur
Post-condition : Aucune
=====================================================================
Test : xA = 1 , yA = 2 , xB = 3 , yB = 5 ; résultat c = 1.5
=====================================================================
Variables : xA,yA,xB,yB,c : réels
Début Algorithme
Ecrire " Entrer la valeur de x pour point A "
Lire xA
Ecrire " Entrer la valeur de y pour point A "
Lire yA
Ecrire " Entrer la valeur de x pour point B "
Lire xB
Ecrire " Entrer la valeur de y pour point B "
Lire yB
c = (yB-yA) / (xB-xA)
Ecrire "Le coefficient directeur vaut :" , c
Fin Algorithme

Exercice 2 : Algorithme de calcul de coefficient directeur – Solution avec sous-programme
 Solution N°1 : exemple de solution avec 1 sous-programme
On décide d’utiliser un sous-programme pour saisir les coordonnée des points. Ce sous-
programme gère la saisie de xA,yA,xB,yB
Algorithme Programme Principal Sous-programme pour saisir les

coordonnées des 2 points
===================================== Algorithme SP Saisir_Points
…
=====================================
Variables : xA,yA,xB,yB,c : réels

Voir slide suivant
Début Algorithme
Saisie_Points (xA,yA,xB,yB)
Fin Algorithme

 Sous-programme pour saisir les coordonnées des 2 points

Algorithme SP Saisir_Points
=================================================================================
Nom : PROCEDURE Saisie_Points
Sémantique: Assure la saisie des coordonnées des 2 points
Spécifications
Paramètres:

xA (IN/OUT) - réel – Coordonnée xA
yA (IN/OUT) - réel – Coordonnée yA
xB (IN/OUT) - réel – Coordonnée xB
yB (IN/OUT) - réel – Coordonnée yB
pré-condition : Aucune
post-condition : avoir saisie les 4 coordonnées
================================================================================
Test : Saisir des valeurs pour les points et vérifier leurs valeurs dans le
programme principal
================================================================================
PROCEDURE Saisie_Points : xA,yA,xB,yB (IN / OUT) : réels
Début Algorithme
Ecrire " Entrer la valeur de x pour point A "
Algorithme
Lire xA
Ecrire " Entrer la valeur de y pour point A "
Lire yA
Ecrire " Entrer la valeur de x pour point B "
Lire xB
Ecrire " Entrer la valeur de y pour point B "
Lire yB
Fin Algorithme

 Solution N°2 : exemple de solution avec 2 sous-programmes
Algorithme Programme Principal  On décide d’utiliser un sous-programme pour

saisir les coordonnées des points mais ce sous-
=====================================
programme n’est pas le même que le
…
===================================== précédemment. Il appelle lui-même un autre
Variables : xA,yA,xB,yB, c : réels sous-programme
Début Algorithme  Le second sous-programme gère l’interaction

avec l’utilisateur pour la saisie de la valeur
SP Saisie_Points (xA,yA,xB,yB)
Fin Algorithme
Un sous-programme dédié à la gestion de l’interaction

Un sous-programme pour saisir les coordonnées des 2 avec l’utilisateur pour la saisie de la valeur à la saisie
points d’une valeur
Algorithme SP Saisir_Points Algorithme SP Demander_Valeur
Voir slide suivant Voir slide suivant

 Sous-Programme Saisie_Points
Algorithme SP Saisie_Points
============================================================
Nom : PROCEDURE Saisie_Points
Sémantique: Assure la saisie des coordonnées des 2 points
Paramètres:
Spécifications

xA (IN/OUT) - réel – Coordonnée xA
yA (IN/OUT) - réel – Coordonnée yA
xB (IN/OUT) - réel – Coordonnée xB
yB (IN/OUT) - réel – Coordonnée yB
pré-condition : aucune
post-condition : avoir saisie les 4 coordonnées
============================================================
Test : Saisir des valeurs pour les points et vérifier leurs
valeurs dans le programme principal
============================================================
PROCEDURE Saisie_Points : xA,yA,xB,yB (IN/OUT) : réels
Début Algorithme
Ecrire " pour xA "
Algorithme
xA <- SP Demander_Valeur
Ecrire " pour yA "
yA <- SP Demander_Valeur Sous programme
Ecrire " pour xB " demandé
xB <- SP Demander_Valeur
Ecrire " pour yB "
yB <- SP Demander_Valeur
Fin Algorithme

 Sous-Programme Demander_Valeur
Algorithme SP Demander_Valeur
========================================================

Nom : FONCTION Demander_Valeur
Spécifications
Sémantique: Assure la saisie d’une valeur
Paramètres:
valeur (OUT) - réel – valeur à saisir
post-condition : avoir saisi la valeur
========================================================
Test : Entrer une valeur et vérifier cette valeur dans le
programme principal
==================================================================
FONCTION Demander_Valeur retourne réel valeur
Variable valeur : réel
Algorithme
Début Algorithme
Ecrire " Entrer la valeur souhaitée "

Lire valeur
Retourner valeur
Fin Algorithme

Exercice 3 : Faire deviner un nombre - Correction
R0 : Faire deviner un nombre entre 0 et 10 en 3 essais
R1 : Raffinage de {Faire deviner un nombre entre 0 et 10 en 3 essai}

| Saisir le nombre à deviner
| Faire
| Entrer une proposition de nombre
| Contrôler si la proposition est correcte
| Incrémenter le nombre de coup
| Afficher un message au joueur
| Tant que nombre est faux et qu’il reste des coups
R2 : Raffinage de {Saisir le nombre à deviner}

| Faire
| Ecrire " Entrer le nombre à deviner entre 0 et 10 : "
Raffinage donné
| Lire nombre_a_deviner
| Si nombre_a_deviner < 0 ou nombre_a_deviner > 10
| Alors Afficher " Le nombre doit être compris entre 0 et 10 "
| Fin Si
| Tant que nombre_a_deviner < 0 ou nombre_a_deviner > 10 Question : On choisit
| retourner nombre_a_deviner
de faire 4 sous-
R2 : Raffinage de {Entrer une proposition de nombre} programmes à partir du
| Faire
| Ecrire " Entrer votre proposition entre 0 et 10 : " raffinage. Donner la
| Lire nombre_proposé
| Si nombre_proposé < 0 ou nombre_proposé > 10 définition de ces sous-
| Alors Afficher " Le nombre doit être compris entre 0 et 10 "
| Fin Si programmes et du
| Tant que nombre_proposé < 0 ou nombre_proposé > 10 programme principale
| retourner nombre_proposé
R2 : Raffinage de {Contrôler si la proposition est correcte}

| Si nombre proposé = nombre à deviner
| Alors le nombre proposé est juste
| Sinon le nombre proposé est faux
| FinSi
R2 : Raffinage de {Afficher un message au joueur}

| Si nombre proposé est juste
| Alors Afficher " Gagné !! Bien joué en " nombre de coups
| Sinon Afficher " Ce n’est pas le bon nombre !! Essai encore "
| FinSi

Algorithme SP Saisir_nombre_a_deviner
==============================================================================
Nom : FONCTION Saisir_nombre_a_deviner
Spécifications
Sémantique: Assure la saisie du nombre à deviner

Paramètres:
nombre_a_deviner (OUT) - entier – nombre à deviner
post-condition : avoir saisi le nombre à deviner entre 0 et 10
==============================================================================
Test : Entrer -1 : Message = " Le nombre doit être compris entre 0 et 10 "
Entrer 11 : Message = " Le nombre doit être compris entre 0 et 10 "
Entrer 5 : Message = aucun. Vérifier la valeur dans le programme principal
============================================================================================
FONCTION Saisir_nombre_a_deviner retourne entier nombre_a_deviner
Variables : nombre_a_deviner : entier
Début Algorithme
Algorithme
Faire
Ecrire " Entrer le nombre à deviner : "
Lire nombre_a_deviner
Si nombre_a_deviner < 0 ou nombre_a_deviner > 10
Alors Afficher " Le nombre doit être compris entre 0 et 10 "
Fin Si
Tant que nombre_a_deviner < 0 ou nombre_a_deviner > 10
retourner nombre_a_deviner
Fin Algorithme
1

Algorithme SP Entrer_proposition_nombre
========================================================
Nom : FONCTION Entrer_proposition_nombre
Sémantique: Assure la saisie de la proposition du joueur
Spécifications
Paramètres:

nombre (OUT) - réel – nombre à deviner
post-condition : avoir saisi la proposition du joueur
========================================================================
Test : Entrer -1 : Message = " Le nombre doit être compris entre 0 et 10 "
Entrer 11 : Message = " Le nombre doit être compris entre 0 et 10 "
Entrer 5 : Message = aucun. Vérifier la valeur dans le programme principal
====================================================================================
FONCTION Entrer_proposition_nombre retourne entier nombre
Variables nombre : entier
Début Algorithme
Algorithme
Faire
Ecrire " Entrer votre proposition de nombre "
Lire nombre
Si nombre < 0 ou nombre > 10
Afficher " Le nombre doit être compris entre 0 et 10 "
Fin Si
Tant que nombre < 0 ou nombre > 10
Retourner nombre
2
Fin Algorithme

Algorithme SP Contrôler_proposition_correcte
================================================================================
===========
Nom : FONCTION Contrôler_proposition_correcte

Spécifications
Sémantique: contrôle si la proposition du joueur est correcte
Paramètres:
sol (IN) - entier – solution à deviner
prop (IN) - entier – proposition du joueur
victoire (OUT) - entier – indique si la partie est gagnée
pré-condition : avoir une valeur dans sol et prop
post-condition : attribuer une valeur à victoire
===============================================================================
Test : prop = 2 , sol = 2 ; résultat : victoire = 1 ;
prop = 2 , sol = 1 , résultat : victoire = 0
============================================================================================
FONCTION Contrôler_proposition_correcte ( sol,prop (IN) : entier ) retourne entier victoire
Début Algorithme
Algorithme
Variable : victoire : entier
Si prop = sol
Alors victoire=1
Sinon victoire=0
FinSi
Retourner victoire
Fin Algorithme
3

Algorithme SP Afficher_message_utilisateur
========================================================
Spécifications
Nom : PROCEDURE Afficher_message_utilisateur

Sémantique: Afficher un message à l’utilisateur
Paramètres:
victoire (IN) – réel – contient victoire (1) ou défaite (0)
pré-condition : victoire doit valoir 0 ou 1
post-condition : Aucune
========================================================
Test : victoire = 1 – résultats : Message " Gagné !! Bien joué "
victoire = 0 – résultats : " Ce n’est pas le bon nombre !! "
==================================================================
PROCEDURE Afficher_message_utilisateur ( victoire (IN) : entier )
Début Algorithme
Algorithme
Si victoire=1
Alors Afficher " Gagné !! Bien joué "
Sinon Afficher " Ce n’est pas le bon nombre !! "
FinSi
Fin Algorithme

Exercice 3 : Faire deviner un nombre – Correction
Algorithme du Programme Principal

===================================================================================
Nom : Algorithme du Jeu faire deviner un nombre
Paramètres :
Sol : entier – nombre à trouver
Prop : entier – nombre proposé
nb_coup : entier – nombre de coups joués
victoire : entiers – nombre surveillance la fin du jeu
Post-condition : Afficher résultat du jeu
====================================================================================
Test : Entrer Sol=2 comme nombre à faire deviner. Proposer pour Prop une valeur > et
vérifier la réponse. Proposer pour Prop une valeur < et vérifier la réponse. Proposer
2 et vérifier la victoire et le nombre de coup qui doit valoir nb_coup = 3 .
====================================================================================
Variables : sol , prop , nb_coup=0 , entier, victoire =0 : entiers
Début Algorithme
sol <- SP Saisir_nombre_a_deviner 1

Faire
prop <- SP Entrer_proposition_nombre 2
Victoire <- SP Contrôler_proposition_correcte (prop) 3
nb_coup = nb_coup + 1 ;
SP Afficher_message_utilisateur (victoire) 4
Tant que (victoire=0) et ( nombre de nb_coup < 3)
Fin Algorithme
On choisit de faire 4 sous-programme à partir du raffinage

(N7-3EA) (Cours Raffinage Algo) (2020-2021) (ETU)

Transféré par

Informations du document

Titre original

Copyright

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 :

(N7-3EA) (Cours Raffinage Algo) (2020-2021) (ETU)

Titre original :

Transféré par

Droits d'auteur :

Département EEEA - 1 ère année

Département EEEA 1ère année 1

L'objectif de cette matière consiste à appréhender les différentes notions liées à la

Département EEEA 1ère année 2

 Etre capable de développer et programmer une application informatique

Cahier des charges

Département EEEA 1ère année 3

 1 ( 1,75h) Cours : Présentation Algorithmique et Méthode de raffinage

 3 Séances découverte Langage C

 EXAMEN INDIVIDUEL ECRIT : 1h ( cours Raffinage / Algorithmique )

 1 RAPPORT de BE par binôme : Rapport Simulateur Circuit RL

Département EEEA 1ère année 4

La réalisation d’un programme informatique passe systématiquement

 Un algorithme est une suite d’opérations ou d’instructions permettant de

 Dans le domaine informatique, un algorithme est INDEPENDANT du

 L’algorithme doit permettre au programmeur d’avoir tous les éléments

 Pour décrire un algorithme, plusieurs formalismes de représentation

Département EEEA 1ère année 5

 Exemple : Algorithme pour un diabolo ( menthe ou fraise )

Alors Mettre du sirop de menthe Menthe

Alors Mettre du sirop de fraise

Département EEEA 1ère année 6

ETAPE 1 : Lecture du cahier des charges et Raffinage

ETAPE 2 : Construction de l’algorithme

Département EEEA 1ère année 7

Département EEEA 1ère année 8

Qu’est-ce qu’un Processeur

Humain Robot Machine Ordinateur

Qu’est ce qu’une action élémentaire ?

Qu’est qu’une donnée ?

Département EEEA 1ère année 9

 Pour aider un concepteur à concevoir un algorithme, nous proposons de suivre une

2 Il faut identifier les principales données manipulées. Des données

3 Il faut ensuite décomposer l’action principale à l’aide d’actions plus

c’est le processus de raffinage

 Reprenons l’exemple de la préparation d’un diabolo menthe

Version Ecrite R0 : Préparer un diabolo menthe

R1 : Prendre un R1 : Mettre de la R1 : Mettre du sirop R1 : Mettre un

Département EEEA 1ère année 11

Version Ecrite R0 : Préparer un diabolo menthe

R2 : Raffinage de {Mettre de la limonade dans le verre}

R1 : Prendre un R1 : Mettre de la R1 : Mettre du R1 : Mettre un Niveau 1

Département EEEA 1ère année 12

 Le critère d’arrêt de la décomposition dépend du problème et de l’expérience du

R3-A1 R3-A2 R3-A3 R3-A4

Département EEEA 1ère année 13

R0 : Action Principale Niveau 0

R1 : Raffinage de {Action Principale}

R2 : Raffinage de {Action R1-A1}

Département EEEA 1ère année 14

Version Ecrite Version Arbre

R0 : Action Principale Niveau 0

R1 : Raffinage de {Action Principale}

R2 : Raffinage de {Action R1-A1}

R2 : Raffinage de {Action R1-A2} R2 - A1 R2 - A2 R2 - A3 R2 - A4 Niveau 2

R3 : Raffinage de {Action R2-A2}

Département EEEA 1ère année 15

 On va souvent avoir besoin d’inclure dans le raffinage des structures de

Département EEEA 1ère année 16

R1 : Raffinage de {Action Principale}

OUI NON Niveau 1

Département EEEA 1ère année 17

R1 : Raffinage de {Action Principale}

Département EEEA 1ère année 18

R1 : Raffinage de {Préparer un diabolo}