Responsable du cours : Mme Fatma KALLEL JAOUA

Equipe pédagogique : Mr Riadh TURKI, Mme Ilhem FRIKHA, Mme Nahla FENDRI, Mme Najla CHAABENE
Auditoire :1ère Année Licence en IG (e-Business)

Corrigé TD/TP N°4 : Algorithmique et Programmation 1

Les instructions itératives
Exercice N°1
Écrire un algorithme puis un programme qui calcule et affiche la somme des 101 premiers entiers :
S=0+1+2+3+….+…+..+99+100
Corrigé
Somme des 101 premiers entiers  Boucle Pour Traitement
Données en Entrée : Ø S0
Données en Sortie : S= somme des 101 premiers entiers Compteur =1 jusqu’à 100
On a un seul affichage  Écrire en dehors de la boucle. S  S + valeur du Compteur
#include <stdio.h> Algorithme Ex1
void main() Var S, i : Entier
{ Début
int i,S=0; S0
for (i=0; i<=100; i++) Pour i de 1 À 100 Faire
S+=i; S  S+i
printf("Somme de 0 A 100 = %d\n",S); FinPour
} Écrire ("Somme de 0 A 100 = ",S)
Fin

Exercice N°2
Ecrire un algorithme puis un programme qui affiche le carré des 20 premiers entiers :
CARRE de 1 est 1
CARRE de 2 est 4
.
.
CARRE de 20 est 400
Corrigé
Carré de 1 à 20  Boucle Pour Traitement
Données en Entrée : Ø Compteur =1 jusqu’à 20
Données en Sortie : 20 carrés Afficher Carré (Compteur)
On a 20 affichages  Écrire dans la boucle.
#include<stdio.h> #include <stdio.h> Algorithme Ex2
void main() #include <math.h> Var i : Entier
{ void main()
int i; { Début
for (i=1; i<=20; i++) Double i; Pour i de 1 À 20 Faire
printf("CARRE de %d =%d\n",i,i*i); for (i=1; i<=20; i++) Écrire ("Carré de ",i," est ",i*i)
} printf("CARREde%.0f= %.0f\n",i, pow(i,2)); FinPour
} Fin

Exercice N°3
Écrire un algorithme puis le programme qui permet d'afficher tous les nombres pairs qui existent entre 1 et 10 dans
l'ordre croissant.
Corrigé
Existent entre 1 et 10 Boucle Pour Traitement
Données en Entrée : Ø Compteur =1 jusqu’à 10
Corrigé TD/TP N°4 2021/22 Page 1 sur 12
Données en Sortie : les nombres pairs existant entre 1 et Si Compteur divisible par 2 alors afficher la valeur du
10. compteur
On a plusieurs affichages  Écrire dans la boucle.
1ère Méthode
#include<stdio.h> Algorithme Ex3
void main() Var i : Entier
{ Début
int i; Écrire ("Les nombres pairs entre 1 et 10 sont :")
printf("Les nombres pairs entre 1 et 10 sont :\n"); Pour i de 1 À 10 Faire
for (i=1; i<=10; i++) Si i Mod 2 =0
if(!(i%2)) // (i%2==0) Alors
printf("%d \t",i); Écrire (i)
printf("\n"); Finsi
} FinPour
Fin
ème
2 Méthode sans condition
#include<stdio.h> Algorithme Ex3
void main() Var i : Entier
{ int i; Début
printf("Les nombres pairs entre 1 et 10 sont :\n"); Écrire ("Les nombres pairs entre 1 et 10 sont :")
for(i=2; i<=10; i+=2) Pour i de 2 À 10 Pas 2 Faire
printf("%d\t",i); Écrire (i)
printf("\n"); FinPour
} Fin

Exercice N°4
Écrire un algorithme puis un programme qui permet d'afficher tous les nombres impairs entre 50 et 100 dans l'ordre
décroissant tout en calculant leur somme et l’afficher.
Corrigé
Compris entre 50 et 100 Boucle Pour Pour leur somme, On a un seul affichage  Écrire
Données en Entrée : Ø en dehors de la boucle.
Données en Sortie : les nombres impairs existant entre 50 et Traitement :
100 dans l'ordre décroissant et leur Somme S0
Pour les nombres impairs, On a plusieurs affichages Compteur =100 jusqu’à 50 Pas =-1
 Écrire dans la boucle. Si Compteur Mod 2 ǂ 0 alors afficher la valeur du
compteur et S  S + Compteur
1ère Méthode
#include <stdio.h> Algorithme Ex4
void main() Var S, i : Entier
Début
{ int i,S=0;
Écrire ("Les nombres impairs de 100 à 50 sont :")
printf("Les nombres impairs entre 100 et 10 sont :\n"); S0
for (i=100; i>=50; i-- ) Pour i de 100 À 50 Pas -1 Faire
if (i%2) // (i%2 !=0) Si i Mod 2 ǂ0
Alors
{
Écrire (i)
printf("%d \t",i); S  S+i
S+=i ; Finsi
} FinPour
printf("\nSomme des nbres impairs de 100 à 50 = %d\n", S); Écrire ("Somme des nbres impairs de 100 à 50 =", S)
} Fin

2ème Méthode sans condition

#include<stdio.h> Algorithme Ex4

Corrigé TD/TP N°4 2021/22 Page 2 sur 12

void main() Var S, i : Entier
{ int i,S=0; Début
printf("Les nombres impairs entre 100 et 10 sont :\n"); Écrire ("Les nombres impairs de 100 à 50 sont :")
for (i=100; i>=50; i-=2) S0
{ Pour i de 99 À 50 Pas -2 Faire
printf("%d \t",i); Écrire (i)
S+=i; S S+i
} FinPour
printf("\nLeur Somme = %d\n",S); Écrire ("Somme des nbres impairs de 100 à 50 =", S)
} Fin

Exercice N°5
Écrire un algorithme puis un programme qui permet d’afficher les multiples de 5 qui sont compris entre 5 et 101
dans l’ordre croissant.
Utiliser les différentes boucles
Corrigé
Données en Entrée : Ø Traitement
Données en Sortie : les multiples de 5existants entre 5 et Compteur =5 jusqu’à 101
101 Si Compteur Mod 5 =0 alors afficher la valeur du
On a plusieurs affichages  Écrire dans les boucles. compteur
Boucle POUR 1ère Méthode Boucle Répéter 1ère Méthode Boucle TANT QUE1ère Méthode
Algorithme Ex5 Algorithme Ex5 Algorithme Ex5
Var i : Entier Var i : Entier Var i : Entier
Début Début
Début Écrire("Multiples de 5 de 5 à 101") Écrire("Multiples de 5 de 5 à 101")
Écrire("Multiples de 5 de 5 à 101") i=5 i=5
POUR i de 5 À 101 Faire Répéter Tant Que i<=101 Faire
Si i Mod 5 = 0 Si i Mod 5 = 0 Si i Mod 5 = 0
Alors Alors Alors
Écrire (i) Écrire (i) Écrire (i)
Finsi Finsi Finsi
FinPour i  i+1 i  i+1
Fin Jusqu’à i >101 FinTantQue
Fin Fin
Programmes C correspondants
#include <stdio.h> #include <stdio.h> #include <stdio.h>
void main() void main() void main()
{ /* Boucle for */ {/* Boucle do ... while */ { /* Boucle while */
int i; int i=5; int i=5;
printf("Multiples de 5 entre 5 et 101 sont : \n"); printf("Multiples de 5 entre 5 et 101 sont : \n"); printf("Multiples de 5 entre 5 et 101 sont : \n");
for (i=5; i<=101; i++) do while(i<=101)
if (!(i%5))// (i%5==0) { if (!(i%5)) { if (!(i%5))
printf("%d\t",i); printf("%d\t",i); printf("%d\t",i);
printf("\n"); i++; i++;
} } while (i<=101); }
printf("\n"); printf("\n");}
}
Boucle POUR 2ème Méthode Boucle Répéter 2ème Méthode Boucle TANT QUE2ème Méthode
Algorithme Ex5 Algorithme Ex5 Algorithme Ex5
Var i : Entier Var i : Entier Var i : Entier
Début Début Début
Écrire("Multiples de 5 de 5 à 101") Écrire("Multiples de 5 de 5 à 101") Écrire("Multiples de 5 de 5 à 101")
POUR i de 5 À 101 Pas 5 Faire i=5 i=5

Corrigé TD/TP N°4 2021/22 Page 3 sur 12

Écrire (i) Répéter Tant Que i<=101 Faire
FinPour Écrire (i) Écrire (i)
Fin i  i+5 i  i+5
Jusqu’à i >101 FinTantQue
Fin Fin
Programmes C correspondants
#include <stdio.h> #include <stdio.h> #include <stdio.h>
void main() void main() void main()
{ /* Boucle for */ {/* Boucle do ... while */ { /* Boucle while */
int i; int i=5; int i=5;
printf("Multiples de 5 entre 5 et 101 sont : \n"); printf("Multiples de 5 entre 5 et 101 sont : \n"); printf("Multiples de 5 entre 5 et 101 sont : \n");
for (i=5; i<=101; i+=5) do while(i<=101)
printf("%d\t",i); { printf("%d\t",i); { printf("%d\t",i);
printf("\n"); i+=5; i+=5;
} } while (i<=101); }
printf("\n"); printf("\n");
} }

Exercice N°6
Écrire un algorithme puis un programme qui permet de saisir et d’afficher un nombre compris entre 1 et 10.
Corrigé
Un nombre compris entre 1 et 10 Le nombre On a un seul affichage  Écrire en dehors de la boucle.
de saisies n’est pas connu d’avance, il peut être Traitement
1 ou plusieurs ≥1 Boucle Répéter Répéter
Données en Entrée : Nb : entier Saisir Nb
Données en Sortie : Nb Jusqu’à (1≤ Nb ≤ 10): condition d’arrêt
#include <stdio.h> Algorithme Ex6
void main() Var Nb : Entier
{ int N; Début
do Répéter
{ printf("Donner un Nombre entre 1 et 10 : "); Écrire ("Donner un nombre :")
scanf("%d",&N); Lire(Nb)
}while ((N<1)||(N>10)); Jusqu’à Nb≥1 ET Nb ≤10
printf("La valeur saisie est %d\n",N); Écrire (Nb)
} Fin

Exercice N°7
Écrire un algorithme puis un programme qui permet de saisir une lettre de l’alphabet (en majuscule ou en
minuscule) en trois tentatives, puis afficher la lettre lue ou le message suivant :
DESOLE ! Vous avez trois tentatives…
Corrigé
Saisir une lettre de l’alphabet  Le nombre de Répéter Saisir L
saisies n’est pas connu d’avance, il peut être 1 ou Tentative  Tentative +1
plusieurs  ≥1 Boucle Répéter Jusqu’à (L ≥"A" ET L ≤ "Z") OU(L ≥"a" ET L ≤ "z") OU
Données en Entrée : L : caractère (Tentative=3)
Données en Sortie : L ou message d’erreur (L ≥"A" ET L ≤ "Z")
On a un seul affichage  Écrire en dehors de la
boucle. Vrai OU
Traitement
Faux (L ≥"a" ET L ≤ "z")
Tentative  0
Afficher la lettre Désolé ! Vous avez 3 tentatives
#include <stdio.h> Algorithme Ex7
void main() Var T : Entier

Corrigé TD/TP N°4 2021/22 Page 4 sur 12

{ L : caractère
char L; Début
int T=0; T0
do Répéter
{ printf("Donner une lettre de l'alphabet : "); Écrire ("Donner une lettre de l'alphabet :")
fflush(stdin); // pour vider la zone Tampon Lire(L)
scanf("%c",&L); T  T+1
T++; Jusqu’à (L ≥"A" ET L ≤ "Z") OU(L ≥"a" ET L ≤ "z") OU (T=3)
}while ((T<3)&&((L<65)||(L>122)||((L>90)&&(L<97))))
Si (L ≥"A" ET L ≤ "Z") OU(L ≥"a" ET L ≤ "z")
if (((L>=65)&&(L<=90))||((L>=97)&&(L<=122))) Alors
printf("OK La lettre est %c\n",L); Écrire ("OK. La lettre est ",L)
else Sinon
printf("DESOLE ! Vous avez trois tentatives...\n"); Écrire ("Désolé ! Vous avez 3 Tentatives")
} Finsi
Fin

Exercice N°8
Écrire un algorithme puis unprogrammequi permet de
1. saisir N (>0) valeurs entières ;
2. déterminer leur somme ;
3. déterminer leur produit;
4. déterminer leur moyenne arithmétique;
5. afficher leur somme, produit et moyenne.
Corrigé
Le nombre de saisie de N n’est pas connu d’avance  Traitement
≥1 Boucle Répéter Répéter
La somme de N entiers  Boucle Pour Saisir N
Le produit de N entiers  Boucle Pour Jusqu’à N >0
Données en Entrée : N : le nombre des entiers Compteur de 1 à N
X : la valeur d’un entier à saisir Saisir X
Données en Sortie : S = somme des N entiers S  S+X N fois
P =produit des N Entiers P  P*X
M =S/N M S/N une seule fois
#include <stdio.h> Algorithme Ex8
void main() Var N,i, X, S : Entier
{ P : Entier Long
int i,N,X,S=0; M : Réel
long int P=1; Début
float M; Écrire ("Donner le nombre d’entiers ")
/* Saisie du nombre d'entiers >0 */ Répéter
do Lire(N)
{printf("Donner le nombre d'entiers "); Jusqu’à N>0
scanf("%d",&N); S0
} while (N<=0) P1
/* Saisie des N entiers et calcul de la somme et du Pour i de 1 à N Faire
produit */ Écrire ("Donner l’entier ", i)
for (i=1; i<=N; i++) Lire(X)
{ S  S+X
printf("Entier No %d : ",i); P  P*X
scanf("%d",&X); FinPour
S+=X; M S/N
P*=X; Écrire ("Somme =", S,"Produit=",P, "et Moyenne =",M)
} Fin
Corrigé TD/TP N°4 2021/22 Page 5 sur 12
// Calcul de la moyenne arithmétique
M=(float)S/N;
/* Affichage des Résultats */
printf("Somme de %d entiers =%d\t ",N,S);
printf("Produit = %ld\t et Moyenne =%f\n",P,M);
}

Exercice N°9
Écrire un algorithme puis un programme qui saisit un nombre pair N puis détermine combien de fois il est
divisiblepar 2.
Exemple : 8 est divisible 3 fois par 2 (2*2*2).
Corrigé
Un nombre N pair  Boucle #include <stdio.h> Algorithme Ex 9
répéter void main() Var N, Nb : Entier
Nombre de fois multiple de 2 { Debut
 ≥1 Boucle répéter int N,nb=0; Écrire ("Donner un entier PAIR ")
Données en Entrée : do Répéter
N un entier pair { printf("donner un nombre pair : "); Lire(N)
Données en Sortie : scanf("%d",&N); Jusqu’à N Mod 2 =0
Nb : Nbre de fois multiple de }while (N%2); Nb 0
2 printf("%d est divisible par 2 ",N); Répéter
Traitement do Si N Mod 2 = 0
Répéter Saisir N { if (!(N%2)) nb++; Alors Nb  Nb+1
Jusqu’à N est pair N/=2; Finsi
Répéter } while (N) N  N DIV 2
Si N Mod 2 =0 printf("%d fois\n",nb); Jusqu’à N=0
Alors Nb Nb+1 Finsi } Écrire (N,"est divisible ", Nb, "fois par 2")
N  N DIV 2 Fin
Jusqu’à N =0

Exercice N°10
Écrire un algorithme puis un programme qui permet de saisir un nombre N positif, de calculer et d’afficher son
factoriel donné par la formule suivante :
F = N *(N-1) * … *3*2*1
Sachant que pour N=0, F=1.
Corrigé
Un nombre N positif #include <stdio.h> Algorithme Ex10
 Boucle répéter void main() Var N,i : Entier
Calcul de F  Boucle Pour { F : Entier Long
Données en Entrée N : int i,N; Début
entier positif ou nul long int F=1; Répéter
Données en Sortie F : do Écrire ("Donner un entier POSITIF")
factorielle de N { Lire(N)
Traitement printf("Donner un entier positif : "); Jusqu’à N ≥ 0
Répéter Saisir N scanf("%d",&N); F 1
Jusqu’à N ≥ 0 } while (N<0); Si N≠0
Compteur de N à 1 if (N) Alors
F  F* Compteur { for (i=N; i>=2;i--) Pour i de N à 2 Pas -1 Faire
F*=i; F  F*i
} FinPour
Finsi
printf("%d ! = %ld\n",N,F); Écrire (N, "! =", F)
} Fin

Corrigé TD/TP N°4 2021/22 Page 6 sur 12

Exercice N°11
Un nombre est dit premier s’il est divisible uniquement par 1 et lui-même.
a> Écrire un algorithme puis un programme qui permet de saisir un entier strictement positif et vérifie s’il
est premier ou non.
Saisir un entier N >0  Boucle répéter Compteur de 1 à N
Recherche du nombre des diviseurs de N Si N Mod Compteur=0 alors NbDiv NbDiv+1
 Boucle Pour
Données en Entrée N : entier positif ou nul Si NbDiv ≤2 Alors N Premier
Données en Sortie : Message (N premier ou non) Sinon N non premier
Traitement Finsi
Répéter Saisir N Jusqu’à N > 0
#include <stdio.h> Algorithme Ex 11a
void main() Var N, i, NbDiv : Entier
{ int i,N,NbDiv=0; Début
/* Saisie d'un entier >0 */ Écrire ("Donner un entier STRICTEMENT POSITIF")
do Répéter
{ printf("Donner un entier STRICTEMENT positif : "); Lire(N)
scanf("%d",&N); Jusqu’à N > 0
}while (N<=0); NbDiv 0
/* Recherche du nombre de diviseurs de N */ Pour i de 1 À N Faire
for (i=1; i<=N;i++) Si N MOD i = 0
if (!(N%i)) NbDiv++; Alors NbDiv NbDiv+1
Finsi
if (NbDiv <=2) FinPour
printf("%d est premier\n",N); Si NbDiv ≤2
else Alors Écrire (N, "est Premier")
printf("%d n'est pas premier\n",N); Sinon Écrire (N, "Non Premier")
} Finsi
Fin
b> Il s’agit ensuite d’afficher tous les nombres premiers compris entre 1 et 100.
Les nombres premiers  Boucle Pour Compteur2 de 1 À Compteur1
Recherche du nombre des diviseurs de chaque entier Si compteur1 Mod Compteur2=0
entre 1 et 100  Boucle Pour alors NbDiv NbDiv+1
Données en Entrée : Ø
Données en Sortie : Message (Nombre premier ou non) Si NbDiv ≤2 Alors Compteur1 Premier
Traitement Sinon Compteur1 non premier
Compteur1 de 1 à 100
#include <stdio.h> Algorithme Ex 11b
void main() Var i, j, NbDiv : Entier
{ Début
int i,j,NbDiv; Pour j de1 À 100 Faire
printf("Les nombres premiers entre 1 et 100 sont\n"); NbDiv 0
for (j=1;j<=100;j++) Pour i de 1 À j Faire
{ Si j MOD i = 0
NbDiv=0; Alors NbDiv NbDiv+1
for (i=1; i<=j;i++) Finsi
if (!(j%i)) NbDiv++; FinPour
Si NbDiv ≤2
if (NbDiv <=2) Alors Écrire (j, "est Premier")
printf("%d \t",j); Sinon Écrire (j, "Non Premier")
} Finsi
printf("\n"); FinPour
} Fin

Corrigé TD/TP N°4 2021/22 Page 7 sur 12

Exercice N°12
Écrire un algorithme puis un programme qui permet de saisir un entier strictement positif puis vérifier s’il est parfait
ou non.
Un nombre est dit parfait s’il est égal à la somme de ses diviseurs (à part lui-même). Par exemple 6=1+2+3.
Corrigé
Saisir un entier N >0  Boucle répéter Compteur de 1 à N-1
Recherche du nombre des diviseurs de N Si N Mod Compteur=0
 Boucle Pour alors SomDivSomDiv+ Compteur
Données en Entrée N : entier strictement positif
Données en Sortie : Message (N Parfait ou non) Si N=SomDiv ou N =1
Traitement Alors N Premier
Répéter Saisir N Jusqu’à N > 0 Sinon N non premier
#include <stdio.h> Algorithme Ex 12
void main() Var N, i, SomDiv : Entier
{ int i,N,S=0; Début
do// Saisie d'un entier > 0 Répéter
{ printf("Donner un entier positif non nul : "); Écrire ("Donner un entier STRICTEMENT POSITIF")
scanf("%d",&N);} Lire(N)
while (N<=0); Jusqu’à N > 0
/* Calcul de la somme des diviseurs de N */ SomDiv 0
for (i=1; i<=(N-1);i++) Pour i de 1 À N-1 Faire
if (!(N%i)) S+=i; Si N MOD i = 0
/* Vérification de N est Parfait ou non */ Alors SomDivSomDiv+i
if ((N==S)||(N==1)) Finsi
printf("%d est PARFAIT\n",N); FinPour
else Si (N=SomDiv)
printf("%d n'est pas Parfait\n",N); Alors Écrire (N, "est Parfait")
} Sinon Écrire (N, "Non Parfait")
Finsi
Fin
b> Afficher tous les nombres parfaits existants entre 1 et 1000
#include<stdio.h> Algorithme Ex 12b
void main() Var j, i, SomDiv : Entier
{ int i,j,S; Début
printf("Nombres PARFAITS entre 2 et 1000 sont:\n"); Écrire ("Nombres PARFAITS entre 2 et 1000 sont:")
for(j=2; j<=1000;j++) Pour j de 2 À 1000 Faire
{ S=0; SomDiv 0
/* Calcul de la somme des diviseurs de j */ Pour i de 1 À j-1 Faire
for (i=1; i<=(j-1);i++) Si j MOD i = 0
if (!(j%i)) S+=i; Alors SomDivSomDiv+i
/* Vérification de N est Parfait ou non */ Finsi
if ((j==S)||(j==1)) FinPour
printf("%d \t",j); Si (j=SomDiv) Alors Écrire (j)
} Finsi
printf("\n"); FinPour
} Fin

Exercice N°13
Soit la suite numérique définit comme suit :
U0 = 1 U1 = 2 Un= Un-1+4*Un-2 Pour tout n>1
a> Écrire un algorithme puis un programme qui permet de lire n le terme de la suite, calculer et afficher la
valeur de Un

Corrigé TD/TP N°4 2021/22 Page 8 sur 12

Saisir un entier n ≥ 0  Boucle répéter U2=U1+4*Uo

En Entrée : n le terme de la suite : entier U3=U2+4*U1

En Sortie : La valeur de Un
Traitement Afficher Uo
V U4=U3+4*U2
n=0 ? V Afficher U1
n=1 ? Compteur de 2 À n
F Un = U1+4*Uo
Uo=U1
F Calculer Un  Boucle Pour U1=Un
#include <stdio.h> Algorithme Ex13a
void main() Var n,i,Un,Uo,U1 : Entier
{ int i,n,Un,U0=1,U1=2; Début
/* Saisie du terme de la suite n */ Uo 1
do U1  2
{printf("Terme de la suite ? "); Répéter
scanf("%d",&n); Écrire ("Donner le terme de la suite :")
}while (n<0); Lire(n)
if (!n) // (n==0) Jusqu’à n≥ 0
printf("U de terme 0 = %d\n",U0); Si n=0 Alors Écrire ("U de terme",n," =",Uo)
else Sinon
{ if (n==1) Si n=1 Alors Écrire ("U de terme",n," =",U1)
printf("U de terme %d = %d\n",n,U1); Sinon
else Pour i de 2 À n Faire
{ for (i=2;i<=n; i++) Un  U1+4*Uo
{ Un=U1+4*U0; Uo U1
U0=U1; U1  Un
U1=Un; } FinPour
printf("U de termen= %d =%d\n",n,Un); Écrire ("U de terme n=",n," =",Un)
} Finsi
} Finsi
} Fin
b> Écrire un algorithme puis un programme qui permet de lire une valeur Val, de chercher la valeur et le rang
du premier terme de la suite supérieure à Val. C à d chercher n et Untel que Un > V.
Saisir un entier Val ≥ 0  Boucle répéter
En Entrée : Val une valeur : entier
Un>V
En Sortie : n : Le terme de la suite Afficher n et Un
Un : valeur de Un
Traitement Afficher n=0 et Uo
V
Uo≥Val Afficher n=1 et U1 n n+1
?? F U1≥Val V Un  U1+4*Uo
? F chercher n et Un Uo U1
tel que Un>V : Boucle Répéter U1  Un

n=2 calculer Un

#include <stdio.h> Algorithme Ex13b

void main() Var Val, n, Uo, U1, Un : Entier
{ Début
int n,Un,U0=1,U1=2,Val; Uo 1
/* Saisie de la valeur Val */ U1  2
printf("La VALEUR ? "); Écrire ("Donner la Valeur :")

Corrigé TD/TP N°4 2021/22 Page 9 sur 12

scanf("%d",&Val);} Lire(Val)
if (U0>Val) Si Uo > Val
{ n=0; Alors n0
Un=Uo;} Un Uo
else Sinon
{ if (U1>Val) Si U1>Val
{ n=1; Alors n=1
Un=U1} Un=U1
else Sinon
{ n=1; n 1
do Répéter
{ n++; nn+1
Un=U1+4*U0; Un U1+4*Uo
U0=U1; Uo U1
U1=Un; U1  Un
} while (Un<=Val); Jusqu’à (Un>Val)
} Finsi
} Finsi
printf(" Le terme n= %d et U %d = %d>%d\n",n,n,Un,Val); Écrire ("terme n = ",n," et U",n,"=",Un,">",Val)
} Fin

Exercice N°14
Écrire un algorithme puis un programme qui permet de saisir les moyennes des N étudiants d’une classe et de
calculer et d’afficher la moyenne générale de la classe ainsi que les pourcentages des étudiants ayant la moyenne et
ceux qui n’ont pas de moyenne. N : étant un entier positif à saisir.
Corrigé
En entrées : Traitement
N : Nombre des étudiants entier >0  Boucle répéter MC = Somme(Moy) (dans la boucle)
Moy : Moyenne d’un étudiant : Réel Boucle répéter puis MC= MC/ N (en dehors de la boucle)
dans la Boucle Pour PM = Nombre des étudiants ayant 10 ou plus
En Sortie : (dans la boucle) puis
MC : Moyenne de la classe : Réel PM=P M*100/ N (en dehors de la boucle)
PM : Pourcentage des étudiants ayant la moyenne PN = Nombre des étudiants n’ayant pas 10 (dans la
PN : Pourcentage des étudiants n’ayant pas la moyenne boucle) puis PN=PN*100/ N (en dehors de la boucle)
#include<stdio.h> Algorithme EX 14
void main() Var N, i : Entier
{ int N,i; Moy, MC, PM, PN : Réel
float Moy, MC, PM, PN; Début
do Répéter
{ printf("Donner le nombre des etudiants : "); Écrire("Donner le nombre des étudiants : ")
scanf("%d",&N); Lire (N)
}while (N<=0); Jusqu’à N >0
MC=PM=PN=0; MC ← 0
PM ← 0
PN ← 0
for(i=1; i<=N;i++) Pour i de 1 à N Faire
{ do Répéter
{printf("Donner la moyenne de l'etudiant %d : ",i); Écrire("Donner la moyenne de l’étudiants : ",i)
scanf("%f",&Moy); Lire (Moy)
}while ((Moy <0)||(Moy >20)); Jusqu’à Moy ≥0 ET Moy ≤20
MC+=Moy; MC ← MC+ Moy
if (Moy >=10) Si Moy ≥ 10
PM++; Alors PM ← PM +1
else Sinon PN ← PN +1
Corrigé TD/TP N°4 2021/22 Page 10 sur 12
 PN++; Finsi
} FinPour
printf("\nMoyenne de la classe est %.2f\n",MC/N); Écrire("La moyenne de la classe est ", MC/N)
printf("\nPoucentage ayant la moyenne = %.2f\n",PM*100/N); Écrire("Pourcentage ayant la moyenne est ", PM*100/N)
printf("\nPoucentage n'ayant pas la moyenne =%.2f \n", PN*100/N); Écrire("Pourcentage n’ayant pas la moyenne est ", PN*100/N)
} FIN

Exercice N°15
Soit l’algorithme suivant qui permet de calculer le PPCM de deux entiers par la méthode des divisions successives.
1. Écrire le programme correspondant :
ALGORITHME DIVISION #include <stdio.h>

void main()

VAR a,b,r : Entier {

DEBUT int a, b,r ;

ÉCRIRE ("donner les valeurs de a et b : ") printf("donner les valeurs de a et b : ") ;

LIRE (a,b) scanf("%d%d",&a,&b) ;

TANT QUE b>0 FAIRE while(b>0)

DEBUT {

r a MOD b ; r= a%b ;

a b ; a=b ;

br; b=r ;

FIN }

ÉCRIRE (a) ; printf("%d\n",a) ;

FIN }

2. Exécuter le programme pour :

a 50 21 96
b 45 13 81
r 5 1 3

Exercice N°16
Écrire un algorithme puis un programme qui permet de saisir une suite de chiffres non nuls terminée par zéro, puis
afficher le nombre correspondant.
Exemple : 1 2 3 4 5 0
Affiche 12345
Corrigé
Suite de chiffres non nuls terminée par zéro  Boucle En Sortie :
Tant que (le 1er chiffre saisi peut être zéro) N= le nombre cherché
En entrées : Traitement
c : un chiffre compris entre 0 et 9  Boucle répéter N=c puis N=N*10+c jusqu’à la saisie de zéro
#include <stdio.h> Algorithme Ex16
Corrigé TD/TP N°4 2021/22 Page 11 sur 12
void main() Var c : Entier
{ N= Entier Long
int c=1; // n’importe quelle valeur autre que zéro Début
long int N=0; c 1
while (c) // c!=0 N0
{ // Saisie des chiffres d'un nombre Tant que c ǂ0 Faire
do Répéter
{printf("Donner un chiffre du Nombre : "); Écrire("Donner un chiffre du Nombre : ")
scanf("%d",&c); Lire(c)
} while ((c<0) || (c>9)); Jusqu’à c≥0 ET c≤9
if (c) Si c ǂ0
N=N*10+c; Alors N N*10+c
} Finsi
FinTantQue
printf("%ld est le Nombre cherche\n",N); Écrire(N,"est le nombre cherché")
} Fin

Exercice N°17
Écrire un algorithme puis un programme qui permet de saisir une suite de chiffres non nuls terminée par zéro, puis
afficher le nombre correspondant à l’envers.
Exemple : 1 2 3 4 5 0
Affiche 54321
Corrigé
Suite de chiffres non nuls terminée par zéro En Sortie :
 Boucle Tant que (le 1er chiffre saisi peut N= le nombre cherché
être zéro) Traitement
En entrées : nombre de chiffres -1
N=c *100 puis N=N+c*10
c : un chiffre compris entre 0 et 9 jusqu’à la saisie de zéro
 Boucle répéter
#include <stdio.h> #include <stdio.h> Algorithme Ex17
#include <math.h> void main() Var c,i : Entier
void main() { N= Entier Long
{ int i=0; // 1ère puissance de 10 Début
int i=0; // 1ère puissance de 10 int c=1; i 0
int c=1; long int N=0; c 1
// n’importe quelle valeur autre que zéro while (c) N0
long int N=0; { do Tant que c ǂ0 Faire
while (c) { printf("Donner un chiffre : "); Répéter
{ do scanf("%d",&c); Écrire("Donner un chiffre")
{ printf("Donner un chiffre : "); }while ((c<0)||(c>9)); Lire(c)
scanf("%d",&c); if (c) Jusqu’à c≥0 ET c≤9
}while ((c<0)||(c>9)); { N+=c*i; Si c ǂ0
if (c) i*=10; Alors
{ N+=c*pow(10,i); } N N+c*10i (ou N+c*i
i++ ;} } i  i+1 et i*10)
} printf("%ld est le nombre\n",N); Finsi
printf("%ld est le nombre a chercher \n",N); } FinTantQue
} Écrire(N,"=Nombre cherché")
Fin

Corrigé TD/TP N°4 2021/22 Page 12 sur 12