2 Itérations

(histoire de nous rappeler que là encore c'était très facile)

Exercice 1 (boucle pour, somme)
Ecrire l'algorithme de la fonction qui calcule le produit de deux nombres entiers positifs sans faire appel à l'opérateur de multiplication.

fonction calculProdParAdd (nb1 : entier, nb2 : entier) : entier
début
somme <- 0
pour i de 1 à nb2 faire
somme <- somme + nb1
fpour
retourne somme
fin

Exercice 2 (boucle pour, somme, minimum, maximum)
On souhaite établir des statistiques à partir de relevés de températures mensuels. Ecrire un algorithme qui permet de lire le nombre de températures puis les différentes valeurs du relevés et d'imprimer le minimum, le maximum et la moyenne de ces valeurs.

Algorithme
début
écrire («nombre de températures ?»)
nbt <- lire ()
écrire (« entrer température »)
max <- lire ()
min <- max
somme <- 0
pour i de 2 à nbt faire
écrire (« entrer température »)
t <- lire()
si t > max alors
max <- t
sinon si t < min alors
min <- t
fsi
somme <- somme + t
fpour
moy <- somme/nbt
écrire (max)
écrire (min)
écrire (moy)
fin

Exercice 3 (boucle tant que)
Ecrire l'algorithme d'une fonction de saisie d'un mois. On demande à l'utilisateur de saisir un numéro de mois compris entre 1 et 12. On le prévient si le nombre est <1>12 et on lui demande alors d'entrer à nouveau une valeur. Cette demande est répétée tant que l'entrée est incorrecte.

Fonction saisieMois (mois : entier) : entier
début
mois <- lire ()
tant que (mois>12 ou mois<1) alors
écrire (« entrer valeur correcte »)
mois <- lire ()
ftantque
retourne mois
fin

Exercice 4 (boucle tant que)
Ecrire l'algorithme de la fonction qui calcule le quotient q de la division euclidienne de a par b, où a et b sont deux entiers strictement positifs, en utilisant uniquement les opérateurs d'addition et de soustraction.
Rappel : a = b * q + r et r est inférieur à b où r est le reste.

fonction calQuotient (a : entier, b : entier) : entier
début
q <- 0
x <- a
tant que x>=b faire
x <- x – b
q <- q + 1
ftant
retourne q
fin

Exercice 5 (boucle tant que)
Ecrire l'algorithme de la fonction qui compte le nombre de 1 présents dans la représentation binaire d'un nombre entier strictement positif donné.

fonction nbUnRepresBinaire (x : entier) : entier
début
compteur <- 0
tant que nombre > 0 faire
r <- nombre mod 2
si r=1 alors
compteur <- compteur +1
fsi
nombre <- nombre ÷ 2
ftant
retourne compteur
fin

Exercice 6 (boucle tant que, terminaison de type "bascule exclue")
Des skieurs font la queue à un téléphérique qui peut contenir jusqu'à 5 tonnes. On donne les noms et poids (en kg) des skieurs successifs entrant dans le téléphérique. Donnez le nom du dernier skieur admis.

Algorithme
début
poidstotal <- 0
nomskieur <- " "
tant que poidstotal =< 5000
faire nomskieurprec <- nomskieur
nomskieur <- lire ()
poidsskieur <- lire ()
poidstotal <- poidstotal + poidsskieur
ftant écrire (nomskieurprec)
fin

Exercice 7 (boucles imbriquées)
A l'issue d'un concours, on souhaite éditer, pour chaque candidat, son nom et sa moyenne puis la moyenne de tous les candidats. On donne le nombre de candidats puis, pour chaque candidat, son nom suivi de ses 10 notes.

Algorithme
début
nbcandidats <- lire ()
moyenne <- 0
moyennetous <- 0
nbnotes <- 10
smoyenne <- 0
pour i de 1 à nbcandidats faire
nomcandidat <- lire ()
somme <- 0
pour j de 1 à nbnotes faire
note <- lire ()
somme <- somme + note
fpour
moyenne <- somme / nbnotes
écrire (nomcandidat, moyenne)
smoyenne <- smoyenne + moyenne
fpour
moyennetous <- smoyenne / nbcandidats
écrire (moyennetous)
fin

Exercice 8 (boucles imbriquées)
Calculer la moyenne d'âge des n enfants d'un centre aéré (n donnée). La saisie est contrôlée; chaque enfant a un âge compris entre 6 et 14.

Algorithme
début
age_moyen <- 0
n_enfants <- lire ()
pour i de 1 à n_enfants faire
age_enfant <- lire ()
tant que age_enfant < 6 ou ou age_enfant sup 14 faire
écrire ("entrer un âge entre 6 et 14")
age_enfant <- lire ()
ftant
age_moyen <- age_moyen + age_enfant
fpour
age_moyen <- age_moyen ÷ n_enfants
écrire (age_moyen)
fin

Exercice 9 (boucles imbriquées)
L'algorithme de multiplication de l'exercice 1 procède par sommes successives. Le produit X*y consiste à sommer y fois la valeur de x. toutefois, on peut améliorer cet algorithme rudimentaire en multipliant x par deux et en divisant y par deux chaque fois que la valeur de y est paire. Les opérations de multiplication et de division par deux sont des opérations très efficaces puisqu'elles consistent à décaler un bit vers la gauche ou vers la droite.

fonction calculerProduit (x:entier, y:entier) : entier
début
v1 <- x
v2 <- y
produit <- 0
tantque v2 > 0 faire
tantque (v2 mod 2) = 0 faire
v2 <- v2 ÷ 2
v1 <- v1 * 2
ftant
produit <- produit + v1
v2 <- v2 - 1
retourne produit
fin