FS-UMI Module : Algorithmique II

Filière : SMI-S3 2021-2022

TD1 - Correction

(Rappel : Algorithmique I, Tableaux 1D)

Exercice 1:
Écrire un algorithme qui affiche la moyenne d’une suite d’entiers positifs
entrés au clavier. On arrêtera la saisie quand le nombre -1 est entré.
Solution:
Algorithme suite
var n, i :entier;
var moy, s: reels
Debut
s← 0; i← 0;
faire
Ecrire(“donner un entier:”);
Lire(n);
si (n <> -1) alors
s←s+n;
i← i+1;
finsi
tanque (n <> -1);

si (i<>0) alors
moy← s/i;
Ecrire(“Moyenne =”, moy);
sinon
Ecrire(“Aucun entier different de 0 n’a été saisi au
clavier, pas possible de calculer la moyenne”);
/* Ecrire(“Moyenne = “, 0); */
finsi

Page 1/8
Fin
Exercice 2:
1. Écrire un algorithme qui affiche la factorielle d’un nombre entier entré par
l’utilisateur (en utilisant la boucle Pour).
2. Refaire la question 1 en utilisant la boucle TantQue.
Solution:
1. Utilisation de la boucle pour.
Algorithme fact1
var f, n, j: entier
Debut
Faire
Ecrire(“donner un entier positif n:”);
Lire(n);
Tantque (n < 0); /* s’assurer que l’entier saisi est >= 0)*/

f← 1;
pour j← 1 à n faire
f← f * j ;
Finpour
Ecrire(“factorielle de”, n, “est :”, f);
FinSi
Fin

2. Utilisation de la boucle Tantque:

Algorithme fact2
var f, n, j: entier
Debut
Faire
Ecrire(“donner un entier positif n:”);
Lire(n);
Tantque (n < 0); /* s’assurer que l’entier saisi est >= 0)*/
f← 1; j← 1;
TantQue (j<=n)
f← f * j ;

Page 2/8
 j← j+1;
FinTantque
Ecrire(“factorielle de”, n, “est :”, f);
FinSi
Fin
Exercice 3:
Écrire un algorithme qui :
1. lit un entier naturel m au clavier.
2. Calcule et affiche le nombre de chiffres de l’entier m saisi au clavier.
Exemple : l’entier 429 est composé de 3 chiffres.
3. Calcule et affiche la somme des chiffres formant l’entier m.
Exemple : La somme des chiffres composant l’entier 429 est 4+2+9=15.
4. Affiche les chiffres de m en ordre inverse.
Solution:

Algorithme XXXX;
Var n , nbre , som : entier;
Debut
Ecrire(“Donner un entier :”);
lire(n);
nbre ← 0;
som ← 0;
Ecrire(“L’entier “, n,”à l’envers s’écrit comme suit :”);
faire
nbre++;
r ← n % 10;
som ←som + r;
Ecrire(r);
n ←n/10;
Tantque (n <> 0);
Ecrire(“\n Nbre de chiffres composant \n“,n,” est : “, nbre);
Ecrire(“Somme des chiffres de “,n, “ est : \n“, som);
Fin

Page 3/8
Exercice 4:
Écrire un algorithme qui se charge des tâches suivantes:
1. Demande un entier n au clavier.
2. Affiche un message qui indique si l’entier est premier ou pas.
3. Calcule la somme suivante: 0 + 1/4 + 2/9 + 3/16 + ….
Solution:
Algorithme ex_4
var n, j,c: entier
var s: reel
Debut
Faire
Ecrire(“donner un entier n > 1:”);
Lire(n);
Tantque (n <= 1); /* s’assurer que l’entier saisi est > 1)*/

/*2. Affiche un message qui indique si l’entier est premier ou pas.*/

j← 2; c← 0;
TantQue (j<= sqrt(n))
Si (mod(n,i) = 0) alors
c←c+1;
Ecrire(n, “ n’est pas premier”);
Break; /* sortir de la boucle */
FinSi
j← j+1
FinTantque

Si (c = 0) alors
Ecrire(n,“est premier.”);
FinSi

/*3. Calcule de la somme : 0 + 1/4 + 2/9 + 3/16 + ….*/

s← 0; j← 1;
TantQue (j <= n)
s← s + ((reel)j/((j+1)*(j+1))); /* convertir j en réel pour avoir un
résultat réel (éviter la division entière) */
Page 4/8
 j← j+1;
FinTantque
Ecrire(“la somme est:”, s);
Fin

Exercice 5:
Un nombre parfait est un entier positif supérieur à 1, égal à la somme de ses
diviseurs. Exemple : 6 = 1 + 2 + 3
Solution:
Algorithme parfait
var n, j,s: entier
Debut
Ecrire (“Donner un entier :”);
Lire(n);
j← 1; s← 0;
TantQue(j < n)
Si (mod(n,j) = 0) alors
s← s+j;
FinSi
j← j+1;
FinTantque

Si (s=n) alors
Ecrire(n,“est parfait.”);
Finsi
Ecrire(n,“n’est pas parfait.”);
Fin
Exercice 6 :
Nous souhaitons résoudre l’équation suivante : Ax2 +Bx+C = 0, avec A, B et
C sont les paramètres de l’équation (On suppose des entiers). Donner un
algorithme qui permet de lire les trois entiers A, B et C et donne la solution
de l’équation second ordre correspondante.
Solution:

Page 5/8
Algorithme resoudre_eq
var a, b, c, d:reels
var s1, s2: reels
Debut
Ecrire(“Donner les trois parametres a,b,c:”);
Lire(a,b,c);
Ecrire(“votre equation est:”, a, “x^2 +”, b, “x +”,c, “=0”);
d← b*b – 4*a*c;
Si (d > 0) alors
s1← (-b+sqrt(d))/(2*a);
s2← (-b-sqrt(d))/(2*a);
Ecrire(“l’ equation a deux solutions distinctes:\n”);
Ecrire(“s1= “,s1, “et s2 = ”, s2,”\n”);
Sinon
Si (d = 0) alors
s1← -b/(2*a);
Ecrire(“l’equation a une unique solution s = ”, s1,”\n”);
Sinon
Ecrire(“l’equation n’a pas de solution réelle \n”);
FinSi
FinSi
Fin

Exercice 7 :
Proposer un algorithme qui s’occupe des tâches suivantes:
1. Déclare un tableau d’entiers Tab de taille 10.
2. Lit les éléments du tableau Tab à travers le clavier.
3. Vérifie si le tableau est trié dans un ordre croissant ou pas. S’il est trié
aucune action à faire. Sinon, l’algorithme va le trier par ordre croissant.
4. Range ensuite les éléments du tableau Tab dans l’ordre inverse sans utiliser
un tableau d’aide.
5. Affiche le tableau résultant.
6. Calcule la moyenne des éléments du Tab et affiche le résultat.
Solution:
Algorithme ex_7

Page 6/8
const max 10
var t[max], n,i, j, tmp: entier
var s: reels
var test : boolean
Debut
Faire
Ecrire(“donner un entier n <= ”, max);
Lire(n);
Tantque (n > max); /* s’assurer que l’entier saisi est <= max, max est
la taille réelle du tableau en mémoire)*/

/*2. Lit les éléments du tableau Tab à travers le clavier.*/

Pour j← 0 à n-1 faire
Ecrire(“donner l’element ”,j, “:”);
lire(t[j]);
FinPour

/*3. Vérifie si le tableau est trié dans un ordre croissant ou pas.*/

j← 0;
test ←true /* on suppose qu’il est trié par ordre croissant */

Tantque (j<n-1)
si (t[j] > t[j+1]) alors
test = false;
Ecrire(“Tableau non trié par ordre croissant”);
break;
finsi
si (test) alors
Ecrire(“Tableau trié par ordre croissant”);
finsi

/* Trier le tableau par ordre croissant uniquement s’il n’est pas trié,
c’est à dire, test = false. Si test = true, c’est à dire tableau trié, on va rien
faire */

Page 7/8
 si (!test) alors /* Tableau n’est pas trié */
i←0
TantQue (i<n-1)
j ← i+1
TantQue (j<n)
si (t[i] > t[j]) alors
tmp← t[i];
t[i] ← t[j];
t[j] ← tmp;
FinSi
j← j+1;
FinTantque
i← i+1
FinTantque
finsi

/*4. inverse du tableau sans utiliser un tableau d’aide.*/

j← 0;
TantQue ( j<= n/2)
/* permutation de t[j] avec t[n-1-j] */
tmp← t[j];
t[j]← t[n-1-j];
t[n-1-j]← tmp;
j ← j+1
FinTantque
/*6.Calcule la moyenne des éléments du Tab et affiche le résultat.*/
j← 0;
s ← 0;
TantQue (j<n)
s← s+ t[j];
j← j+1;
FinTantque
s← s/n;
Ecrire(“la moyenne est:”, s);
Fin

Page 8/8