⌂ Algorigrammes
Fiche 9 sur 13

Compteurs, sommes, minimum et maximum

Les quatre gestes que l'on fait sans cesse dans une boucle.

Après cette fiche, vous saurez :

1Quatre gestes, un seul décor

Dans une boucle qui traite plusieurs valeurs (cinq notes, sept températures...), on fait presque toujours l'une de ces quatre choses :

Je veux...Je prépare (avant la boucle)Je fais (dans la boucle)Je finis (après la boucle)
cumulersomme = 0somme += valeurafficher la somme
la moyennesomme = 0somme += valeurmoyenne = somme / n
compternb = 0Si condition : nb++afficher nb
le minimummin = une grande valeurSi valeur < min : min = valeurafficher min
le maximummax = une petite valeurSi valeur > max : max = valeurafficher max

Dans tous les cas, la préparation se fait dans le rectangle de déclaration, avant la boucle. Voyons chaque geste.

2Somme et moyenne

Début int i = 1 double nombre double somme = 0 double moyenne i <= 5 "Nombre {i} :" nombre somme += nombre i++ moyenne = somme / 5 "Somme : {somme}" "Moyenne : {moyenne}" Fin oui non

La somme démarre à 0, et chaque tour y ajoute le nombre saisi. La moyenne se calcule après la boucle, une seule fois, quand la somme est complète.

Passageinombresomme
test n°11?0
test n°221010
test n°331222
test n°44830
test n°551444
test n°66650

Avec 10, 12, 8, 14 et 6, la somme est 50 et la moyenne 10.

Attention

Le calcul de la moyenne ne va jamais dans la boucle.

Calculé à chaque tour, il donnerait des moyennes partielles, et la division par 5 n'aurait pas de sens avant la fin.

Quand on ne connaît pas le nombre de valeurs

Dans l'exemple précédent, on divisait par 5, parce qu'on savait qu'il y aurait 5 valeurs. Mais si l'utilisateur tape des valeurs jusqu'à ce qu'il décide de s'arrêter, le nombre de valeurs n'est pas connu à l'avance. On le compte au fur et à mesure avec un compteur n, et on divise par ce compteur :

Début double valeur double somme = 0 int n = 0 double moyenne "Valeur (-1 pour arrêter) :" valeur valeur != -1 somme += valeur n++ "Valeur (-1 pour arrêter) :" valeur n > 0 moyenne = somme / n "Moyenne de {n} valeurs : {moyenne}" "Aucune valeur saisie" Fin oui non oui non
Passagevaleursommen
test n°11000
test n°212101
test n°38222
test n°4-1303
Ce que l'ordinateur affiche
Valeur (-1 pour arrêter) :
Valeur (-1 pour arrêter) :
Valeur (-1 pour arrêter) :
Valeur (-1 pour arrêter) :
Moyenne de 3 valeurs : 10

Attention

Et si l'utilisateur tape tout de suite -1 ?

Alors n vaut 0, et somme / n est une division par zéro (fiche 5). Le losange n > 0 protège le calcul de la moyenne :

Ce que l'ordinateur affiche
Valeur (-1 pour arrêter) :
Aucune valeur saisie

3Compter ce qui répond à une condition

Pour compter les jours de gel, on place le compteur dans un Si : il n'augmente que quand la condition est vraie.

Début int jour = 1 double temperature int nb_gel = 0 jour <= 5 "Température du jour {jour} :" temperature temperature < 0 nb_gel++ jour++ "Jours de gel : {nb_gel}" Fin oui oui non non

Avec -2, 5, 0, -7 et 3 : les jours 1 et 4 gèlent. Le 0 ne compte pas, car 0 < 0 est faux.

Passagejourtemperaturenb_gel
test n°11?0
test n°22-21
test n°3351
test n°4401
test n°55-72
test n°6632
Ce que l'ordinateur affiche
Jours de gel : 2

Le Si sans « sinon » (fiche 5) est ici idéal : quand la condition est fausse, le chemin contourne le compteur.

4Le minimum et le maximum

L'idée : on garde en mémoire le plus petit (ou le plus grand) vu jusqu'ici. À chaque nouvelle valeur, on la compare, et on la remplace si elle est mieux.

Début int i = 1 double note double note_min = 20 double note_max = 0 i <= 5 "Note {i} :" note note < note_min note_min = note note > note_max note_max = note i++ "Note la plus basse : {note_min}" "Note la plus haute : {note_max}" Fin oui oui non oui non non

Pour des notes sur 20 : note_min démarre à 20 (la plus grande note possible) et note_max à 0 (la plus petite). Ainsi, la première note saisie remplacera forcément les deux.

Passageinotenote_minnote_max
test n°11?200
test n°22121212
test n°337712
test n°4415715
test n°559715
test n°6618718

Attention

Mauvaise valeur de départ : la plus grande erreur sur les minimums.

Si note_min démarrait à 0, aucune note ne serait plus petite que 0 : le minimum resterait à 0 pour toujours, même avec des notes de 12 à 18. Pour un minimum, partez d'une valeur très grande ; pour un maximum, d'une valeur très petite.

Une autre méthode : partir de la première valeur

Quand on ne connaît pas les limites (les valeurs peuvent être n'importe quoi), on utilise la première valeur saisie comme point de départ :

Début int i = 1 double note double note_min double note_max i <= 5 "Note {i} :" note i == 1 note_min = note note_max = note note < note_min note_min = note note > note_max note_max = note i++ "Note la plus basse : {note_min}" "Note la plus haute : {note_max}" Fin oui oui non oui non oui non non

Au tour 1 (i == 1), le minimum et le maximum prennent la valeur de la note. Aux tours suivants, on compare.

À retenir

→Exercices

1Minimum et maximum, version « première valeur »Recopier

Reproduisez cet algorigramme. Déroulez-le avec les notes 12, 7, 15, 9 et 18, en notant note_min et note_max à chaque tour.

Début int i = 1 double note double note_min double note_max i <= 5 "Note {i} :" note i == 1 note_min = note note_max = note note < note_min note_min = note note > note_max note_max = note i++ "Note la plus basse : {note_min}" "Note la plus haute : {note_max}" Fin oui oui non oui non oui non non

Solution

Début int i = 1 double note double note_min double note_max i <= 5 "Note {i} :" note i == 1 note_min = note note_max = note note < note_min note_min = note note > note_max note_max = note i++ "Note la plus basse : {note_min}" "Note la plus haute : {note_max}" Fin oui oui non oui non oui non non
Passageinotenote_minnote_max
test n°11???
test n°22121212
test n°337712
test n°4415715
test n°559715
test n°6618718

À la fin : la note la plus basse est 7, la plus haute 18. La ligne du tour 1 montre que les deux variables prennent d'abord la valeur de la première note.

2Deux compteursModifier

Cet algorigramme compte les jours de gel sur 5 jours.

Début int jour = 1 double temperature int nb_gel = 0 jour <= 5 "Température du jour {jour} :" temperature temperature < 0 nb_gel++ jour++ "Jours de gel : {nb_gel}" Fin oui oui non non

Modifiez-le pour compter aussi les jours de forte chaleur (plus de 30 degrés). Combien de nouvelles formes faut-il ?

Solution

Il faut une nouvelle variable (nb_chaud) et un nouveau Si avec son compteur, dans la boucle. Les deux tests sont indépendants : une température ne peut pas être à la fois de gel et de forte chaleur, mais on pose les deux questions à chaque jour.

Début int jour = 1 double temperature int nb_gel = 0 int nb_chaud = 0 jour <= 5 "Température du jour {jour} :" temperature temperature < 0 nb_gel++ temperature > 30 nb_chaud++ jour++ "Jours de gel : {nb_gel} Jours de forte chaleur : {nb_chaud}" Fin oui oui non oui non non
Ce que l'ordinateur affiche
Température du jour 1 :
Température du jour 2 :
Température du jour 3 :
Température du jour 4 :
Température du jour 5 :
Jours de gel : 1   Jours de forte chaleur : 2
3La note la plus haute de 25 (syllabus P3·7)Créer

Vingt-cinq élèves passent un examen noté de 0 à 20. Dessinez l'algorigramme qui demande les 25 notes et affiche la note la plus haute.

Solution

Comme les notes sont comprises entre 0 et 20, la note la plus haute peut démarrer à 0 : toute note saisie sera supérieure ou égale. À chaque tour, si la note dépasse la meilleure gardée jusqu'ici, on la remplace :

Début int i = 1 double note double plus_haute = 0 i <= 25 "Note {i} :" note note > plus_haute plus_haute = note i++ "La note la plus haute est : " , plus_haute Fin oui oui non non
Ce que l'ordinateur affiche
Note 1 :
Note 2 :
Note 3 :
Note 4 :
Note 5 :
Note 6 :
Note 7 :
Note 8 :
Note 9 :
Note 10 :
Note 11 :
Note 12 :
Note 13 :
Note 14 :
Note 15 :
Note 16 :
Note 17 :
Note 18 :
Note 19 :
Note 20 :
Note 21 :
Note 22 :
Note 23 :
Note 24 :
Note 25 :
La note la plus haute est : 20

Seul le maximum est demandé, donc on n'a pas besoin de variable pour le minimum.

4Les notes réussiesCréer

Huit élèves passent un examen. Dessinez l'algorigramme qui demande les 8 notes, puis affiche combien d'élèves ont réussi (note de 10 ou plus) et le pourcentage de réussite.

Solution

Début int i = 1 double note int nb_reussites = 0 double pourcentage i <= 8 "Note {i} :" note note >= 10 nb_reussites++ i++ pourcentage = nb_reussites * 100.0 / 8 "Réussites : {nb_reussites} sur 8 ({pourcentage} %)" Fin oui oui non non
Ce que l'ordinateur affiche
Note 1 :
Note 2 :
Note 3 :
Note 4 :
Note 5 :
Note 6 :
Note 7 :
Note 8 :
Réussites : 5 sur 8 (62.5 %)

Le pourcentage se calcule après la boucle : nb_reussites * 100.0 / 8. On écrit 100.0 (avec un point) pour que la division donne un résultat à virgule, et non un entier tronqué (fiche 4).

5La moyenne de N élèves (syllabus P3·8)Créer

Dessinez l'algorigramme qui fait entrer les notes (de 0 à 20) d'un nombre N d'élèves, et affiche la moyenne. Entre chaque note, le programme demande « Voulez-vous continuer ? (o/n) ».

Chaque note doit être comprise entre 0 et 20 (sinon, elle est redemandée).

Solution

C'est l'exercice le plus complet de la fiche, et il réunit plusieurs idées :

  • une boucle « o/n » qui entoure tout (fiche 8) ;
  • à l'intérieur, une saisie contrôlée de la note (une boucle dans une boucle) ;
  • une somme et un compteur n : comme N n'est pas connu, la moyenne se calcule avec somme / n, après la boucle.
Début int n = 0 double note double somme = 0 double moyenne string encore "Note de l'élève (0 à 20) :" note note < 0 || note > 20 "Note impossible" somme += note n++ "Voulez-vous continuer ? (o/n)" encore encore == "o" moyenne = somme / n "Moyenne de {n} élèves : {moyenne}" Fin oui non oui non
Ce que l'ordinateur affiche
Note de l'élève (0 à 20) :
Voulez-vous continuer ? (o/n)
Note de l'élève (0 à 20) :
Note impossible
Note de l'élève (0 à 20) :
Voulez-vous continuer ? (o/n)
Note de l'élève (0 à 20) :
Voulez-vous continuer ? (o/n)
Moyenne de 3 élèves : 10

Ici, la note 25 est refusée (« Note impossible ») et n'est pas comptée : trois élèves, une somme de 30, une moyenne de 10. La boucle « o/n » fait toujours au moins un tour, donc n ne vaut jamais 0 au moment du calcul.

Je sais faire

Une case qui coince ? Relisez la partie concernée avant de passer à la fiche suivante.

← Fiche 8 Fiche 10 : Les boucles imbriquées →