L1S2–MPI TD 2 – GROUPE D1 ROSELINE DESCOUT

ALGORITHMIQUE ET LANGAGE C – L1S2–MPI
ROSELINE DESCOUT-RENIER
TD 2 – GROUPE D1
JEUDI 06 FÉVRIER 2014
Objectifs de la séance :
•
•
Concevoir un algorithme en pseudocode ;
Traduire un pseudo-code en langage C.
Exercices étudiés pendant la séance :
8 – 12 – 13 – 16.
Méthodologie :
•
•
•
Analyse du problème
◦ Pré-traitement (définir les données du problème) ;
◦ Traitement (résolution du problème pas à pas) ;
◦ Affichage du résultat.
Rédaction de l’algorithme en pseudo-code
Traduction du pseudo-code en langage C
Autant que possible, décomposer le code en trois parties séparées : Entrées / Traitement / Sorties, en éliminant les
affichages de la partie Traitement.
Exercice 8 :
Pseudo-code :
Code en C :
#include <stdio.h>
entier note, sortie ;
écrire “ Entrez votre note : ” ;
lire note ;
int main(void) {
/* Entrées. */
int note, sortie;
printf ("\nEntrez votre note :");
scanf ("%d", &note);
/* Traitements. */
if (note < 8) {
sortie = 1;
}
else /* alors la note est supérieure ou égale à 8 */
if (note < 10) {
sortie = 2;
}
else { /* alors la note est supérieure ou égale à 10 */
sortie = 3;
}
si note < 8 faire
sortie ← 1 ;
sinon faire
si note < 10 faire
sortie ← 2 ;
sinon faire
sortie ← 3 ;
finsi
finsi
/* Sorties. */
switch(sortie) {
case 1 : printf("\nAjournée./n"); break;
case 2 : printf("\nRattrapage./n"); break;
case 3 : printf("\nAdmis./n"); break;
default: printf("\nErreur./n"); break;
}
cas sortie = 1 faire
écrire “ Ajournée ”
cas sortie = 2 faire
écrire “ Rattrapage ”
cas sortie = 3 faire
écrire “ Admis ”
return 0;
}
Conclusion :
L’utilisation de la variable sortie permet de regrouper tous les affichages en fin de traitement.
Un code structuré est un code plus facile à lire pour une tierce personne, donc plus facile à débugger.
Exercice 12 :
Dans un premier temps, réfléchir sur le papier à la façon dont on va calculer le prix des photocopies :
•
•
•
moins de 10 photocopies : chaque photocopie vaut 10 centimes
→ prix = nombre × 0,10
entre 10 et 30 photocopies : les 10 premières valent 10 centimes chaque, les suivantes valent 9 centimes
chaque
→ prix = 10 × 0,10 + (nombre – 10) × 0,09
au-delà de 30 photocopies : les 10 premières valent 10 centimes chaque, les 20 suivantes valent 9 centimes
chaque, les dernières valent 8 centimes chaque
→ prix = 10 × 0,10 + 20 × 0,09 + (nombre – 30) × 0,08
→ besoin d’une variable flottante prix, d’un nombre entier correspondant au nombre de photocopies à faire.
Penser à regrouper les affichages en fin de traitement.
Pseudo-code :
Code en C :
#include <stdio.h>
entier nombre ;
flottant prix ;
écrire “ Entrez votre nombre de photocopies : ” ;
lire nombre ;
int main(void) {
/* Entrées. */
int n;
float prix;
printf ("\nEntrez votre nombre de photocopies :");
scanf ("%d", &n);
/* Traitements. */
if (n < 10) {
prix = n*0.1;
}
else /* alors le nombre de copies est supérieur à 10 */
if (n < 30) {
prix = 1 + (n-10)*0.09;
}
else { /* alors le nombre de copies est supérieur à 30 */
prix = 2.8 + (n-30)*0.08;
}
si nombre < 10 faire
prix = nombre*0.1;
sinon faire
si nombre < 30 faire
prix = 1 + (nombre-10)*0.09;
sinon faire
prix = 2.8 + (nombre-30)*0.08;
finsi
finsi
écrire “ Le prix de ces photocopies vaut ” prix
“ euros. ”
/* Sorties. */
printf("\nLe prix de ces photocopies vaut %f euros.\n",
prix);
return 0;
}
Exercice 13 :
Une condition sur le sexe de la personne, une condition sur l’âge → deux conditions imbriquées
Pseudo-code :
Code en C :
#include <stdio.h>
entier age, imposable ;
caractère sexe ;
écrire “ Etes-vous un homme ou une femme ? ” ;
lire sexe ;
écrire “ Quel est votre âge ? ” ;
lire age ;
int main(void) {
/* Entrées */
int age, imposable;
char sexe ;
printf ("\nEtes-vous un homme (h) ou une femme (f) ?");
scanf ("%c", &sexe);
printf ("\nQuel est votre âge ?");
scanf ("%d", &age);
/* Traitements */
if (sexe == 'h') {
if (age >= 20) {
imposable = 1;
}
else {
imposable = 0;
}
}
if (sexe == 'f') {
if (age >= 18 && age < 35) {
imposable = 1;
}
else {
imposable = 0;
}
}
si sexe = homme faire
si age ≥ 20 faire
imposable = 1 ;
sinon faire
imposable = 0 ;
finsi
finsi
si sexe = femme faire
si age ≥ 18 et age < 35 faire
imposable = 1 ;
sinon faire
imposable = 0 ;
finsi
finsi
/* Sorties */
if (imposable == 0) {
printf("\nVous n'êtes pas imposable.\n");
}
else {
printf("\nVous êtes imposable.\n");
}
si imposable = 0 faire
écrire “ Vous n’êtes pas imposable. ”
sinon faire
écrire “ Vous êtes imposable. ”
finsi
return 0;
}
Remarque : donner dans la question posée une indication sur le type de réponse attendue.
→ si votre code est conçu pour tester ‘h’ ou ‘f’ alors que l’opérateur répond ‘masculin’ ou ‘féminin’, l’exécution du
code donnera des résultats aberrants.
Exercice 16 :
L’énoncé indique clairement que les valeurs ne doivent pas être stockées en mémoire. Il ne s’agit donc pas de créer
un tableau qui sera rempli au fur et à mesure des valeurs données par l’opérateur. Il faut envisager une variable
courante dont la valeur sera remplacée à chaque nouvelle entrée de l’opérateur.
Il n’est donc pas possible de respecter ici la règle de séparation des entrées / traitements / sorties, puisque l’analyse
des valeurs entrées se fera au fil de l’eau.
Pour initialiser les variables min et max, il faut détailler une première fois le traitement, puis automatiser dès la
deuxième valeur avec une boucle tant que. La sortie de la boucle tant que se fait grâce à l’entrée d’une valeur
négative par l’opérateur.
Pseudo-code :
Code en C :
#include <stdio.h>
entier min, max, n ;
écrire “ Entrez votre première valeur : ” ;
lire n ;
int main(void) {
/* Entrées et traitements. */
int min, max, n;
printf ("\nEntrez votre première valeur :");
scanf ("%d", &n);
min ← n ;
max ← n ;
min = n;
max = n;
tant que n ≥ 0 faire
si min > n faire
min ← n ;
finsi
si max < n faire
max ← n ;
finsi
écrire “ Entrez une nouvelle valeur : ”
lire n ;
finsi
while (n >=0) {
if (min > n) {
min = n;
}
if (max < n) {
max = n;
}
printf("\nEntrez une nouvelle valeur :");
scanf ("%d", &n);
}
écrire “ Le minimum vaut ” min “ , le maximum
vaut ” max ;
/* Sorties */
printf("\nLe minimum vaut %d, le maximum vaut %d.\n",
min, max);
return 0;
}
Remarque :
Dans la boucle tant que, si le test est fait avant de remplacer les valeurs min et max, la valeur min sera remplacée
dans le dernier parcours de boucle par la valeur négative servant à clore la série. Il faut donc remplacer les
éventuels min et max, puis demander la nouvelle valeur. Si la nouvelle valeur est négative, la boucle ne sera pas
parcourue à nouveau.
Exercice 16 – complément :
On demande également l’affichage de la position des valeurs min et max.
Pseudo-code :
Code en C :
#include <stdio.h>
entier min, max, position_min, position_max, n,
indice_boucle ;
écrire “ Entrez votre première valeur : ” ;
lire n ;
int main(void) {
/* Entrées et traitements. */
int min, max, position_min, position_max, n,
indice_boucle;
printf ("\nEntrez votre première valeur :");
scanf ("%d", &n);
min ← n ;
position_min ← 1 ;
max ← n ;
position_max ← 1 ;
indice_boucle ← 1 ;
min = n;
position_min = 1;
max = n;
position_max = 1;
indice_boucle = 1;
tant que n ≥ 0 faire
si min > n faire
min ← n ;
position_min ← indice_boucle ;
finsi
si max < n faire
max ← n ;
position_max ← indice_boucle ;
finsi
écrire “ Entrez une nouvelle valeur : ”
lire n ;
indice_boucle = indice_boucle + 1 ;
finsi
while (n >=0) {
if (min > n) {
min = n;
position_min = indice_boucle;
}
if (max < n) {
max = n;
position_max = indice_boucle;
}
printf("\nEntrez une nouvelle valeur :");
scanf ("%d", &n);
indice_boucle++;
}
écrire “ Le minimum vaut ” min “ (en position ”
position_min “, le maximum vaut ” max “ en
position ” position_max “ )” ;
/* Sorties */
printf("\nLe minimum vaut %d (en position %d), le
maximum vaut %d (en position %d).\n", min,
position_min, max, position_max);
return 0;
}

Download Report