1

RESOLUTION EXERCICES
A. CALCUL DE LA COMPLEXITE

1. Ecrire un algorithme qui fait la somme de n nombres lus au clavier

Algorithme Somme_N_nombre
Variable som,nbr,n,i: entier
Début
som<- 0
i <- 1
écrire('Entrez le nombre n somme a calculer : ')
lire(nbr)
si (nbr <= 0) alors
repeter
ecrire("saisir un nombre superieur à O : ")
lire(nbr)
jusqua nbr > 0
sinon
ecrireln("Ecrire les nombres : ")
tantque i <= nbr faire
lire(n)
ecrire(n," + ")
som<-som+n
i<-i+1
fintantque
ecrireln("")
ecrireln("somme : ",som)
finsi
Fin

2. Soient les algorithmes suivants, calculer la complexité de chacun d’eux :

 2

i = 1 i = n
Tantque (i <=n) Faire Tantque (i >=n) Faire
Exécuter le module A Exécuter le module A
i =i +1 i =i /3
Fintantque Fintantque
Pour chaque itération de la boucle Pour chaque itération de la boucle
 Un test  Un test
 Une exécution  Une exécution
 Une incrémentation  Une décrémentation
Au total 3(1 + n) opérations O(n) Au total 3(n / 3) opérations O(log3 n)

i = 1
Tantque (i <=n) Faire
j=1
i = 1 Tantque ( j <= n) Faire
Tantque (i <=n) Faire Exécuter le module A
j=1 J=j*1
Tantque ( j <= n) Faire Fintantque
Exécuter le module A i =i *1
J=j+1 Fintantque
Fintantque
i =i +1 Pour chaque itération de la boucle
Fintantque  Deux tests
 Une exécution
Pour chaque itération de la boucle  Deux incrémentations
 Deux tests Complexité : O(2n )
 Une exécution
 Deux incrémentations
Complexité =nombre d’itération de la grande
boucle multiplier par le nombre d’itération
de la petite boucle. (n *n) ou O(n2 )
 3

i = 1
Tantque (i <=n) Faire
j=1
Tantque ( j <= n) Faire
Exécuter le module A
J=j*4
Fintantque
i =i +1
Fintantque

Pour chaque itération de la boucle

 Deux tests
 Une exécution
 Deux incrémentations
Complexité : O (n log2)

B. ALGORITHMES AVEC FONCTIONS ET PROCEDURES

1. Ecrire un algorithme qui lit le nom d’un étudiant et son année de naissance, et qui affiche le
message suivant
dans une procédure : « NomEtudiant, tu as X ans ».

Algorithme Nom_Annee_Naissance
variables
nom : chaine
annee , ans :entier
procedure AfficheNAN(n:chaine, a:entier)
Début
si (a < 2023 && a >= 1915) alors //on limite les années a calculer
annee<- 2023-a
ecrire(n," tu as ",annee," ans")
sinon
ecrire("annee de naissance anormal")
finsi
Fin
debut
ecrire("entre le nom de l'étudiant : ")
lire(nom)
ecrire("année de naissance : ")
lire(ans)

AfficheNAN(nom,ans) // Appel la procédure

fin
 4

2. Ecrire un programme qui calcule la surface d’un carré et le volume d’un cube
de même côté sachant que
l’utilisateur devra saisir le côté dans l’algorithme principal et calculer le volume
dans une fonction et la
surface dans une autre.

Algorithme Surface_CarreCube
variables
volume, surface:réel
hauteur,longueur,largeur:réel

fonction surfCarre(a:réel, b:réel): réel

Début
surface <- a * b

retourner surface
Fin

fonction VolumeCube(a:réel, b:réel, h:réel): réel

Début
volume <- a * b * h

retourner volume
Fin

//debut algorithme principal

debut
ecrireln("TAPEZ : la Longueur et la largeur du carre : ")
lire(longueur,largeur)
ecrireln( surfCarre(longueur,largeur)," m2") //Appel la 1eme fonction

ecrireln("TAPEZ : la longueur, largeur et la hauteur du CUBE : ")

lire(longueur,largeur,hauteur)

ecrireln(VolumeCube(longueur,largeur,hauteur)," m3") //Appel la 2eme fonction

fin
 5

3. Un commerçant croit avoir obtenu un bénéfice s’il a eu un surplus de plus de

30% sur le montant dépensé.
Etant donné le nombre de sacs de riz n acheté par le client et le prix p par sac
ainsi que le prix de vente PV
par sac, on demande d’écrire un algorithme en utilisant une fonction qui calcule
le prix de vente total et une
autre qui calcule le prix d’achat total, et une procédure qui affiche si le client est
satisfait ou pas.

Algorithme Benefice_Vente_Achat // ALGORITHM PRINCIPAL

variables Début
N, PU_Achat, PU_Vente : entier ecrire("COMBIEN DE SAC DU RIZ AVEZ VOUS
P_tot, V_tot: entier BESOIN : ")
Achats,Ventes, som_PV, som_PA: entier lire(N)
Benefice:entier ecrire("PRIX UNITAIRE UN SAC :
MargeB:réel lire(PU_Achat)
fonction CalPrixAchat(a:entier , b:entier ):entier ecrire(" PRIX DE VENTE : ")
debut lire(PU_Vente)
som_PA <- a * b
si (N >0 && PU_Achat > 0 && PU_Vente >0 ) alors
retourner som_PA
fin Achats <- CalPrixAchat(N,PU_Achat)
fonction CalPrixVente(x:entier , y:entier ):entier Ventes <- CalPrixVente(N,PU_Vente)
debut Client(Achats,Ventes,PU_Achat, PU_Vente)
som_PV <- x * y sinon
ecrireln(" ")
retourner som_PV ecrireln("ERREUR DE SAISI MERCI DE
fin //fin fonction Calcule Achat RECOMMENCER")
finsi
procedure Client(at:entier, vt:entier,r:entier ,rv:entier) Fin
debut
ecrireln("--------------------------------------- ")
ecrireln(" ")
ecrireln("PRIX ACHAT UNITAIRE ",r," Fc")
ecrireln("PRIX DE VENTE ",rv," Fc")
ecrireln("")

Benefice <- vt -at

MargeB <- (Benefice/at) * 100
ecrireln("Prix d'achat total : ",at," Fc")
ecrireln("Prix de Vente total : ",vt," Fc")
ecrireln("Benefice : ",Benefice,
"Fc qui vaut : ",MargeB," %")
si (MargeB >= 30) alors
ecrireln(" ")
ecrireln("SATISFAIT")
sinon
ecrireln("")
ecrireln("CLIENT N'EST PAS SATISFAIT")
finsi
fin
 6

4. Ecrire un algorithme qui calcule la surface d’un trapèze en utilisant une

fonction, connaissant la valeur de
la grande base, la petite base et la hauteur.

Algorithme Trapeze
variables
s, gb,tb,h : réel
fonction CalTrapeze (a:réel, b:réel, c:réel): réel
debut
s <- ((gb + tb)*h)/2
retourner s
fin
Début
Ecrireln ("TAPER : la grande base, petite base et la hauteur du trapèze ")
Lire (gb, tb, h )
Ecrireln (CalTrapeze(gb,tb,h)," Cm2")
Fin

5. Ecrire un algorithme avec une fonction qui convertit les kilomètres en miles
sachant que 1 mile=1.609 Km.

Algorithme Kilometres_Miles
variables
km,m:réel
fonction Conver_KiloMiles(a:réel): réel
Début
m <- a /1.609

retourner m
Fin
debut
ecrire("tapez la distance en Km : ")
lire(km)
ecrireln (Conver_KiloMiles (km)," Miles")
fin
 7

6. Ecrire un algorithme avec une fonction qui calcule le volume d’une sphère à
4 3
partir du rayon Volume sphère ¿ π R
3

Algorithme VolumeSphere
variable
cal,r: réel
fonction CalSphere(a:réel): réel
Début
cal <- (4 * 3.14 * (a)^3)/3

retourner cal
Fin
debut
ecrire("tapez le rayon de la sphère : ")
lire(r)
ecrireln(CalSphere(r))
fin

7. Ecrire un algorithme qui convertit les degrés Fahrenheit en degré centigrade 𝜃𝐶

= (𝜃𝐹 − 32)9

Algorithme Fahrenheit_Centigrade
variable
f,c: reel
fonction Conversion(a:réel): réel
Début
c <- 5/9 *(a -32)

retourner c
Fin
debut
ecrire ("Ecrire un nombre en dégre Fahrenheit : ")
lire(f)

ecrireln (Conversion(f))
fin
 8

8. Ecrire une fonction ayant en paramètres le nombre d’heures effectuées par un

salarié dans la semaine et
son salaire horaire, qui retourne sa paye hebdomadaire.

Algorithme PayeHebdomadaire
variables
jour, sh, t, nbrH, salaireH: entier
fonction payeHeb ( a:entier, b:entier, j:entier) : entier
Début
t <- (a * b) *jour
retourner t
Fin
debut
ecrire ("Nombre d'heure par jour : ")
lire (nbrH)
ecrire("Salaire par heure : ")
lire (salaireH)
ecrire ("Combien de jours avez vous travailler dans la semaine : ")
lire(jour)

si( jour >0 && jour <=7 ) alors

sh <- payeHeb ( nbrH, salaireH, jour)
ecrireln ("votre salaire hebdomadaire : ",sh, " USD")
sinon
ecrireln(" le nombre de la semaine anormal")
finsi

fin
 9

9. Ecrire une fonction ayant en paramètre deux entiers représentant un mois et

une année et retournant le
nombre de jours du mois de cette année.

Algorithme MoisAnnee
variables
x, moi,ans : entier
fonction VoirMoiAnne(m:entier, a:entier): entier
debut

si(m >=1 && m <=12) alors

si( m=1 || m=3 || m=5 || m=7 || m=8 || m=10 || m=12) alors
x <- 31
sinonsi (m=2) alors
si (a mod 2 = 0) alors
x<- 29
sinon
x<- 28
finsi
sinon
x<-30
finsi
sinon
x <- 0
finsi

retourner x
fin
Début
Ecrire ("Saisir LE moi d'une l'année : ")
lire(moi)
ecrire("Son année : ")
lire(ans)
ecrireln (VoirMoiAnne(moi,ans)," jours")
Fin

10. On donne un nombre entier, on demande d’’écrire un algorithme qui simule

une calculatrice avec des
fonctions suivantes en lisant les opérateurs « + » pour l’addition, « - » pour la
 10

différence, « ^ » pour la
puissance, « / » pour la division et « ! » pour la factorielle. Il faudra prévoir une
procédure pour l’affichage
du résultat :
- Somme de A et B
- Différence de A et B

Algorithme CalculatriceS
variables procedure AffichageFinale (a1:entier, a2:entier,
o,i, r, n1,n2:entier adiv:réel,opera:entier )
d:réel debut
s:caractere si (s='/') alors
fonction fact(g:entier) :entier ecrireln("Division de ",a1," par ",a2," = ",adiv)
debut sinonsi (s='*') alors
r<-1 ecrireln("Produit de ",a1," et ",a2," = ",opera)
si (s='!') alors sinonsi (s='+') alors
si (g <= 1) alors ecrireln("Somme de ",a1," et ",a2," = ",opera)
retourner 1 sinonsi (s='-') alors
sinon ecrireln("Différence de ",a1," et ",a2," = ",opera)
pour i=1 à g faire sinonsi (s='^') alors
r <- r * i ecrireln("Puissance de ",a1," et ",a2," = ",opera)
finpour finsi
finsi fin
finsi
retourner r Début
fin ecrire (" Nombre1 : ")
fonction Operateurs(a:entier, b: entier) :entier lire(n1)
debut ecrire("Operation : ")
cas s lire(s)
'+' : r <- a +b si (s='!') alors
'-' : r<-a-b ecrireln("Factorielle de ",n1," = ",fact(n1))
'*' : r<- a*b sinon
'^' : r <- a^b n1<-n1
fincas ecrire("Nombre2 : ")
retourner r lire(n2)
fin
fonction Division (c:réel, d:réel) : réel d <- Division (n1,n2 )
debut o <- Operateurs(n1,n2)
r<-0
si(s = '/')alors AffichageFinale(n1,n2,d,o)
si ( d != 0) alors finsi
r<- c/d Fin
sinon
r<-r
finsi
finsi
retourner r
fin
 11

11. Ecrire une fonction qui retourne la valeur de la factorielle d’un entier lu.

Algorithme factoriel
Variable
n: entier
Fonction fact(n: entier): entier
Début
si (n <= 1) alors
retourner 1
sinon
retourner n*(n - 1)
finsi
Fin

Début
Ecrire ('Entrez un nombre: ')
lire(n)
écrire(n, '! = ', fact(n))
Fin
 12

C. ALGORITHMES AVEC FONCTIONS ITERATIVES ET RECURSIVES

1. Ecrire un algorithme avec une fonction récursive qui calcule la valeur de la racine carrée d’un
nombre réel positif A lu au clavier par la méthode de Newton.

Algorithme RacineCarreeNrwton
variables
a,r,xn,xn1:Reel
fonction Newton (a:reel): reel
Début
xn<-0.1
xn1 <- xn+a/xn
tantque (abs(xn1-xn)>=0.0001) faire
xn<-xn1
xn1<-(xn+a/xn)/2
fintantque

retourner xn1
Fin
debut
affiche(" la racine carrée : ")
lire(r)
affiche("racine carrée de ",r," =", Newton (r))
fin
 13

2. Ecrire un algorithme avec une fonction récursive, qui calcule avec a un réel et n un entier
positif.

1 si n = 0
a = (a ) si n est pair
n n/2 2

a . an-1 si n est impair

Algorithme puissanceA
variable b,r: reel
p:entier
fonction puissance(a:reel,n:entier):reel
Début
si(n=0 )alors
retourner 1
sinonsi (n mod 2 = 0) alors
retourner (a^(n/2))^2
sinon
retourner a * (a^(n-1))
finsi
Fin
debut
ecrire(" Saisir entier A : ")
lire(b)
ecrire(" Saisir son exposant : ")
lire(p)
ecrireln(puissance(b,p))
fin
 14

3. Ecrire une fonction qui retourne le plus petit diviseur premier d’un nombre.

Algorithme PPCM
var
n,m,x,y,r:entier
fonction cal(a: entier, b:entier): entier
Début
x<-a
y<-b
tantque (x<>y) faire
si (x<y) alors
x<-x+a
sinon
y<-y+b
finsi
r<- x
fintantque
retourner r
Fin
debut
ecrire("Saisir le 1er nombre : ")
lire(n)
ecrire("Saisir le 1er nombre : ")
lire(m)
ecrireln("PPCM = ",cal(n,m ))
fin

4. Ecrire une fonction qui calcule la racine carrée entière d’un nombre entier positif. (Principe :
on opère par soustractions successives des nombres impaires, si p est l’entier solution de la
double inéquation
𝑝 𝑝+1

∑(2𝑖 − 1) ≤ 𝑛 < ∑(2𝑖 − 1)

𝑖=1 𝑖=1

Exemple Racine de 75

75-1=74 ; 74-3=71 ; 71-5=66 ; 66-7=59 ; 59-9=50 ; 50-11=39 ; 39-13=26 ; 26-15=11 ; 11-

17=-6 On a fait 8 soustractions avant d’obtenir une valeur négative, donc la racine
entière de 75 c’est 8.
 15

Algorithme RacineCarreSoustraction
var
n,i,p1,p2,r:entier
fonction rac(p:entier):entier
Début
r<-0
pour i=1 à p faire
p1<- (2*i -1)
finpour
pour i=1 à p+1 faire
p2<-2*i -1
finpour
pour i=1 à p faire
si(i mod 2 =1) alors
si(p1<p2 ) alors
p<-p-i
r<-r+1
//ecrireln(p)
finsi
finsi
finpour
retourner r
fin
debut
ecrire("ecrire un nombre ")
lire(n)
ecrireln ("la racine carrée de ",n," est ",rac(n))

Fin

5. Ecrire un algorithme avec une fonction récursive qui calcule la valeur du PGCD de deux
entiers lus.
 16

Algorithme PGCD
var r,n,min,i,m:entier
fonction cal(a:entier, b:entier):entier
Début
si( a>b) alors
min<-b
sinon
min<-a
finsi
pour i de 1 à min+1 faire
si(a mod i = 0 && b mod i= 0 ) alors
r<-i
finsi
finpour
retourner r
Fin
debut

ecrire("saisir le 1er nombre : ")

lire(n)
ecrire("saisir le 2eme nombre : ")
lire(m)
ecrireln(" le PGCD de ",n," et ",m," =
",cal(n,m))
fin

6. Ecrire un algorithme avec fonction récursive qui calcule le nième terme de la suite de
Fibonacci définie de la manière suivante :
 17

U0 = 1
U1 = 1
Un = Un-1 + Un-2

Algorithme fibonacci
Variable
x, i, f, f0, f1 : entier
fonction fib(n:entier):entier
Début
f0 <- 0
f1 <- 1
si(n < 2) alors
ecrire('fib(', n, ') = ')
retourner n
sinon
pour i de 2 à n faire
f <- f0 + f1
f0 <- f1
f1 <- f
finpour
ecrire('fib(', n, ') = ')
retourner f
finsi
Fin
Début

D. ALGORITHMES CONCERNANT LES TABLEAUX

1. Soient les données suivantes concernant un tableau TAB(-1 :5 , 0 :3) :
Base : 412
Nom : TAB
Taille du 4ème élément de la deuxième colonne : 1
Calculer :

a. L’espace total occupé par ce tableau en mémoire lorsque le chargement se fait en

colonne
b. L’adresse du 12ème élément lorsque le chargement est en colonne
c. Les indices du 6ème élément lorsque le chargement se fait en ligne
 18

2. Etant donné une suite de 10 nombres, on demande d’écrire un algorithme capable :

- D’inscrire cette suite dans un tableau ;
- D’afficher chaque élément du tableau ainsi constitué en le faisant précéder de la valeur de
son indice.

Algorithme Suite10nombres
var
i, nbr:entier
tab: tableau [10] de entier
Début
pour i=1 à 10 faire
ecrire("saisir nombre N° ",i, " ")
lire(nbr)
tab[i]<-nbr
finpour
pour i=1 à 10 faire
ecrireln(i," ",tab[i])
finpour
Fin
 19

3. On considère deux matrices 3X3 notée V et W. les coefficients de chacune de ces deux
matrices seront notés V( i , j ) et W( i , j ). Ecrire un algorithme qui permet de calculer
puis afficher la matrice Z=
V+W.

Algorithme matrice3X3Addition
var
v,z,w:tableau[3,3] de entier
i,a,b,j:entier
Début
ecrire("Première matrice ")
pour i=1 à 3 faire
pour j=1 à 3 faire
lire(v[i,j])
finpour
finpour
ecrire("Deuxième matrice ")
pour i=1 à 3 faire
pour j=1 à 3 faire
lire(w[i,j])
finpour
finpour

pour i=1 à 3 faire

ecrire("[")
pour j=1 à 3 faire
z[i,j]<-( v[i,j])+(w[i,j])
ecrire(z[i,j])
finpour
ecrireln("]")
finpour

Fin
 20

4. Soit un tableau K ayant 68 éléments. Transférer les éléments positifs de K dans un

tableau KPOSITIF et les éléments négatifs de K dans un tableau KNEGATIF

algorithme TabK_Positif_Negatif
var tab: tableau [68] de entier
T,n,i,j,a:entier
debut
T<-taille(tab)
ecrireln("positif et négatif")
pour i=1 à T faire
ecrire("nombre N° ",i," : ")
lire(n)
tab[i]<-n
finpour
pour i de 1 à T faire
pour j de i+1 à T faire
si(tab[j]<tab[i]) alors
a<-tab[i]
tab[i]<-tab[j]
tab[j]<-a
finsi
finpour
finpour
pour i de 1 à T faire
si(tab[i]<0) alors
ecrire(tab[i],' ')
finsi
finpour
ecrireln("")
pour i de 1 à T faire
si(tab[i]>0) alors
ecrire(tab[i],' ')
finsi
finpour
Fin

5. Soit un tableau G de 100 éléments, déterminer la longueur de la plus longue séquence de

nombres rangés par ordre croissant et le rang de son premier élément.
 21

6. Soit un tableau TAB possédant 25 éléments. Ranger dans le même tableau les éléments
dans l’ordre inverse.(le premier élément doit être le dernier).
22
 23

Algorithme INVERSE

variable tab: tableau[25] de entier

i, j, temp: entier

Début

tab <-
[7,1,2,3,4,5,6,7,8,9,8,5,6,5,4,14,5,11,10,13,14,15,14,12
,14]

pour i de 1 à 25 faire

pour j de i + 1 à 25 faire

si tab[i]<>tab[j] alors

temp <- tab[j]

tab[j] <- tab[i]

tab[i] <- temp

finsi

finpour

finpour

écrire('[')

pour i de 1 à 25 faire

écrire(tab[i])

si i <> 25 alors

écrire(', ')

finsi

finpour

FIN
 24

7. Ecrire un algorithme qui transfère les éléments d’un tableau T1 dans un tableau T2 selon
le principe suivant : Les éléments de rang impair sont rangés dans T2 en ordre inverse en
commençant par la fin de T2 et les éléments de rang pair de T1 sont rangés dans le
même ordre.

Algorithme TAB2_TAB1
const N=25
var
t1: tableau [N] de entier
i:entier
Début
i<-N
t1<-[1,2,3,4,6,8,7,5,9,10,12,
13,14,15,16,17,18,19,10,20,11,27,32,27,60]
ecrireln("inverse impaires")
tantque (i<>0)faire
si (t1[i] mod 2 =1) alors
ecrire(t1[i]," ")
finsi
i<-i - 1
fintantque
ecrireln("")
ecrireln("------------------------------")
ecrireln("inverse paires")
i<-N
tantque (i<>0)faire
si (t1[i] mod 2 != 1) alors
ecrire(t1[i]," ")
finsi
i<-i - 1
fintantque
Fin
 25

8. Soit T une matrice carrée à 5 lignes et 5 colonnes. Soit F un vecteur à 5 composantes.

Ecrire l’algorithme permettant de calculer l’image du vecteur F par la matrice T.

Algorithme VectueurHuite
var
t: tableau [5,5] de entier
v: tableau [5] de entier
N, k,i,j:entier
Début
N<-taille(v)
t<-[[1,1,1,1,1],[2,2,2,2,2],[3,3,3,3,3],[4,4,4,4,4],
[5,5,5,5,5]]
v<-[2,3,4,5,6]
pour i=1 à N faire
ecrire("[")
pour j=1 à N faire
ecrire(t[i][j]," ")
finpour
ecrireln("]")
finpour
ecrireln("---------")

pour i=1 à N faire

ecrire("[")
pour j=1 à N faire
ecrire( t[i][j] * v[j]," ")
finpour
ecrireln("]")
finpour

Fin
 26

9. Soit un tableau à deux dimensions contenant des nombres quelconques. Remplacer les
valeurs initiales des éléments d’un rectangle inclus dans ce tableau par des zéros. Le
rectangle est déterminé par sa longueur, sa hauteur et les coordonnées du coin supérieur
gauche.
 27

10. Etant donné un tableau de n éléments et un nombre X. Ecrire un algorithme capable :

A. D’afficher le message « l’élément X n’est pas dans le tableau » si X n’est pas parmi les
éléments du tableau ;
B. D’afficher la position de l’élément X dans le cas où il est parmi les éléments du
tableau.

Algorithme TabX_exist_pas
var
t: tableau [10] de entier
p,i,N,a:entier
Début
N<-taille(t)
i<-1
p<--1
t<-[1,11,3,4,5,6,7,8,9,10]
ecrire(" ecrire le nombre a cherché : ")
lire (a)
tantque (i<= N && p=-1) faire
si( a =t[i] ) alors
p<-i
sinon
i<-i+1
finsi
fintantque
si( p<> -1) alors
ecrireln( p," est a la position ",i)
sinon
ecrireln("n'existe pas ")
finsi

Fin
 28

11. L’école secondaire ‘‘Les Joyeux Lurons’’ a décidé de gérer les perceptions des frais des
élèves à l’aide de deux tableaux. Le premier nommé ELEVE possède 1200 lignes et 2
colonnes dans sa première colonne on
y enregistre les noms des élèves et la seconde colonne l’année d’étude. Le deuxième tableau
nommé PERCEPTION possède 1200 lignes et 10 colonnes chaque colonne représente un mois
à partir de Septembre.
Lorsqu’un élève n’a pas encore payé pour un mois, la cellule du deuxième tableau se
trouvant à l’intersection de la ligne représentant l’élève et la colonne représentant le mois a
la valeur 0.
Un élève peut payer par tranche les frais mensuels. Dans ce cas on ajoute le montant payé
au montant qu’il avait déjà payé.
L’information se trouvant à la ligne i dans le deuxième tableau correspond à l’élève se
trouvant à la ligne i dans le premier tableau.
Ecrire un algorithme :

a. Qui affiche pour le mois de Septembre la liste des étudiants qui n’ont pas encore
payé.
b. Qui affiche le montant global perçu pour chaque mois
c. Qui met à jour le paiement du mois de novembre d’un élève dont le nom, la classe et
le montant seront lus.
d. En supposant que les élèves de première et deuxième année doivent payer
mensuellement 5000Fc et les autres 9500Fc, écrire un algorithme qui affiche à la fin
de l’année la liste de tous les élèves de cette école qui ont des dettes, en indiquant
les montants de dette par mois et par élèves.
e. En considérant les informations de la sous question d. écrire un algorithme qui
affiche la liste des élèves qui sont en ordre pour le mois de Mai.