TD d'ALGORITHMIQUE n°3 - traitements séquentiels - Free

Corrigé du TD d'algorithmique n°3
[pic]
MSG 2 option SI
actions itératives
Exercice 1
Trouver la valeur des variables x, y et z à l'issue des algorithmes
suivants. Ecrire l'état des variables à l'issue de chaque action. a - début [pic] Exercice 2
a - Ecrire un algorithme itératif qui calcule la somme des entiers de 1 à
n. Parcours d'une séquence de longueur fixe [pic]
Fonction somme(n: entier) ( entier
lexique
i: entier
début
somme < 0;
pour i allant de 1 à n faire
somme < somme + i;
fin b - Ecrire un algorithme itératif qui calcule la somme des entiers impairs
de 1 à n. Parcours d'une séquence de longueur fixe [pic]
Fonction somme_impair(n: entier) ( entier
lexique
i: entier
début
somme_impair < 0;
pour i allant de 1 à n faire
si i mod 2 = 1 alors
somme_impair < somme_impair + i;
fin Autre solution :
Fonction somme_impair(n: entier) ( entier
lexique
i: entier
début
somme_impair < 0;
pour i allant de 1 à n pas 2 faire
somme_impair < somme_impair + i;
fin Exercice 3
Ecrire un algorithme qui calcule le montant capitalisé après n années à
un taux d'intérêt taux à partir d'un capital initial C (on suppose qu'on ne
dispose que des opérateurs * et +).
Parcours d'une séquence de longueur fixe [pic] Fonction capital(c: réel, taux: réel, n: entier) ( réel
lexique
i: entier
début
capital < c;
pour i allant de 1 à n faire
capital < capital * (1 + taux);
fin Exercice 4
Ecrire un algorithme qui calcule la factorielle du nombre n. On rappelle
que la fonction factorielle (notée !) est calculée comme suit:
0! = 1
?n 1, n! = 1 x 2 x ... x (n - 1) x n Parcours d'une séquence de longueur fixe [pic]
Fonction fact(n: entier) ( entier
lexique
i: entier
début
fact < 1;
pour i allant de 1 à n faire
fact < fact * i;
fin
Exercice 5
Ecrire un algorithme qui demande à l'utilisateur n (n connu) nombres, et
affiche leur produit. Parcours d'une séquence de longueur fixe [pic]
action produit(n: entier)
lexique
i, x, prod: entier
début
prod < 1;
pour i allant de 1 à n faire
début
lire(x);
prod < prod * x;
fin;
écrire("produit: " , prod);
fin
Exercice 6
Ecrire un algorithme qui demande à l'utilisateur n (n connu) nombres, et
en affiche leur max. et leur min. Parcours d'une séquence de longueur fixe [pic]
action min_max(n: entier)
lexique
i, x, min, max: entier
début
min < +(;
max < -(;
pour i allant de 1 à n faire
début
lire(x);
si x < min alors min ( x;
si x > max alors max ( x;
fin;
si n > 0 alors
écrire("min :", min, " max : ", max)
sinon écrire("min et max impossibles à calculer")
fin
Exercice 7
Ecrire un algorithme qui demande à l'utilisateur n (n connu) nombres et
affiche leur somme et leur moyenne. Parcours d'une séquence de longueur fixe [pic] la moyenne peut être calculée après le parcours de la séquence
action somme_moyenne(n: entier)
lexique
i, x, somme: entier
début
somme < 0;
pour i allant de 1 à n faire
début
lire(x);
somme < somme + x;
fin;
écrire("somme : ", somme);
si n > 0 alors
écrire("moyenne :" , somme/n);
fin
Exercice 8
Ecrire un algorithme qui demande à l'utilisateur n (n connu) nombres et
affiche le nombre de fois où l'utilisateur a rentré le nombre 10. Parcours d'une séquence de longueur fixe [pic]
action calcule_nombre_10(n: entier)
lexique
i, x, nombre_10: entier
début
nombre_10 < 0;
pour i allant de 1 à n faire
début
lire(x);
si x = 10 alors
nombre_10 < nombre_10 + 1;
fin;
écrire("nombre de 10: ", nombre_10);
fin
Exercice 9
Ecrire un algorithme qui, de manière répétitive, demande à l'utilisateur
un nombre entier positif et affiche le carré de ce nombre. Cette opération
est répétée jusqu'à ce que l'utilisateur entre le nombre 0. Parcours d'une séquence de longueur variable Traitement itératif : [pic]
condition d'arrêt : x = 0 action affiche_carres(n: entier)
lexique
x: entier
début
x < 1;
tant que x ( 0 faire
début
lire(x);
si x ( 0 alors ecrire(x*x);
fin;
fin; Autre solution : Traitement itératif :
[pic]
Condition d'arrêt : x = 0 action affiche_carres(n: entier)
lexique
x: entier
début
lire(x);
tant que x ( 0 faire
début
ecrire(x*x);
lire(x);
fin;
fin;
Exercice 10
Ecrire un algorithme qui, de manière répétitive, demande à l'utilisateur
un nombre entier. Cette opération est répétée jusqu'à ce que l'utilisateur
entre un nombre inférieur au précédent nombre entré. On affiche alors les
deux derniers nombres entrés. Parcours d'une séquence de longueur variable Traitement itératif : [pic] Condition d'arrêt : x < prec action supérieur_précédent
lexique
x, prec: entier
début
lire(x);
prec ( x-1;
tant que x ( prec faire
début
prec ( x;
lire(x);
fin;
écrire("deux derniers nombres : ", prec, " ", x);
fin; Autre solution : action supérieur_précédent
lexique
x, prec: entier
début
lire(prec);
lire(x);
tant que x ( prec faire
début
prec ( x;
lire(x);
fin;
écrire("deux derniers nombres : ", prec, " ", x);
fin;
Exercice 11
Ecrire un algorithme qui, de manière répétitive, demande à l'utilisateur
un nombre entier. Cette opération est répétée jusqu'à ce que ce
l'utilisateur entre le nombre 0. Si au bout de 10 nombres entrés,
l'utilisateur n'a toujours pas entré 0, l'algorithme affiche le message:
« vous n'avez pas entré 0 » et s'arrête. Dans le cas contraire, il affiche
les message: « vous avez entré 0 » et s'arrête.
Recherche dans une séquence de longueur variable Traitement itératif : [pic] Condition d'arrêt : i = 10 ou x = 0
action différent_0
lexique
i, x: entier
début
lire(x);
i ( 1;
tant que i ( 9 et x ( 0 faire
début
lire(x);
i ( i + 1; {quand on a lu 10 nombres, i vaut 10}
fin;
{i = 10 ou x = 0}
si x = 0 alors
écrire("vous avez entré 0");
sinon écrire("vous n'avez pas entré 0");
);
fin;
Exercice 12
Soient a, b, c trois nombres consécutifs dans une séquence de nombres, on
dit que b est un « pic » si b > a et b > c. nombres, on dit que b est un
« creux » si b < a et b < c. Ecrire un algorithme qui demande à l'utilisateur n (n connu supérieur ou
égal à 3) nombres et affiche le nombre de pics et de creux dans la séquence
parcours d'une séquence de longueur fixe [pic] action pic_creux(n: entier)
lexique
i, xp1, xp2, x, nbpic, nbcreux: entier
début
nbcreux ( 0 ;
nbpic ( 0 ;
lire(xp2);
lire(xp1);
pour i allant de 1 à n-2 faire
début
lire(x);
si x < xp1 et xp1 > xp2 alors nbpic ( nbpic + 1;
si x > xp1 et xp1 < xp2 alors nbcreux ( nbcreux + 1;
xp2 < xp1;
xp1 < x;
fin;
écrire("nombre de pics : ", nbpic, " - nombre de creux : ",
nbcreux);
fin
----------------------- lire(x);
si x ? 0 alors
écrire(x*x) écrire(x*x);