Algorithmique & Structures de données Travaux Dirigés

TD5 : Les Types Composés

Partie 1 : Les tableaux
Exercice N°1 :
Soit T un tableau contenant Nmax éléments de type entier.
Q1. Ecrire un sous-algorithme Taille qui permet de saisir la taille N>0 du tableau
(Nmax=50).
Q2. Ecrire un sous-algorithme Remplir qui permet de remplir le tableau B de N entiers
positifs et paire.
Q3. Ecrire un sous-algorithme Afficher qui permet d’afficher les éléments du tableau dans
l’ordre de saisie.
Q4. Ecrire un sous-algorithme AffTabInv qui permet d’afficher les éléments du tableau
dans l’ordre inverse.
Q5. Ecrire un sous-algorithme MinTab qui retourne le plus petit élément de ce tableau.
Q6. Ecrire un sous-algorithme Rechercher qui permet de rechercher une valeur P entrée
au clavier dans le tableau X (non trié). Afficher la première position (indice) de P si elle se
trouve dans le tableau, sinon afficher un message d’erreur.
Q7. Ecrire un sous-programme Occurrence qui calculer et retourne le nombre
d’occurrences d’un entier C dans un tableau d’entiers.
Q8. Écrire un sous-algorithme Inverser qui permet d’inverser l'ordre des éléments dans
le tableau X. Ainsi si le tableau contient les valeurs [2 ; 3 ; 5 ; 6 ; 9 ; 7], on aura comme résultat
le tableau suivant : [7 ; 9 ; 6 ; 5 ; 3 ; 2].
Q9. En utilisant les sous-algorithmes précédents, écrire l’algorithme qui permet de :
 Saisir N,
 Remplir le tableau
 Afficher le contenu du tableau,
 Afficher le contenu du tableau dans l’ordre inverse,
 Afficher le minimum du tableau,
 Afficher la première position d’un entier saisi par l’utilisateur s’il existe dans le
tableau X sinon afficher un message d’erreurs,
 Afficher le nombre d’occurrence d’un entier saisi par l’utilisateur.
 Afficher le tableau après l’inversion de son contenu.

Exercice N°2 :
Q1. Ecrire un sous-algorithme qui permet d’éclater un vecteur d’entiers VE en deux :
 Un vecteur VP contenant les entiers pairs.
 Un vecteur VI contenant les entiers impairs.
Q2. En utilisant les sous-algorithmes précédents, écrire l’algorithme qui permet de :
 Saisir N,
 Remplir le tableau
 Afficher le contenu du tableau,
 Afficher le tableau des paires et le tableau des impaires.

D.Cheriti,I.Daoud & L.Ayedi -1-

Algorithmique & Structures de données Travaux Dirigés

Exercice N°3 :
Un instituteur cherche à vérifier si ses élèves ont appris à réciter l’alphabet lettre par lettre
dans l’ordre. Pour ceci, Il vous demande de lui développer l’algorithme et les sous-algorithmes
d’un programme permettant d’évaluer chaque élève de la façon suivante :
Q1. Le programme demande à chaque élève de remplir un tableau nommé réponse par les
lettres de l’alphabet dans l’ordre. Ecrire un sous-algorithme REMPLIR qui remplit le tableau
réponse.
Q2. Ecrire sous-algorithme CORRIGER qui permet d’examiner le tableau réponse
élément par élément :
 Si la lettre est dans sa place, il l’accepte.
 Sinon, il la remplace par la lettre adéquate et incrémente le nombre de fautes
Q3. En utilisant les sous-algorithmes précédents, écrire l’algorithme qui permet de :
 saisir les réponses de l’élève
 d’afficher le nombre total de fautes commises par l’éléve.
Exercice N°4 :
Q1. Ecrire un sous-algorithme qui permet de vérifier si les éléments du tableau de taille
N sont dans l’ordre croissant ou non.
Q2. Ecrire un sous-algorithme qui permet de fusionner deux tableaux V1 de taille N et
V2 de taille M en un troisième tableau V3 de taille N+M trié dans l’ordre croissant.
Q2 : Ecrire un algorithme qui permet de :
 Remplir deux tableaux V1 de taille N et V2 de taille M et de vérifier s’ils sont
trié dans l’ordre strictement croissant,
 Fusionner les deux tableaux en un troisième tableau V3 trié dans l’ordre croissant.

Exercice N°5 :
Q1. Ecrire un sous-algorithme InsereVal qui insère une nouvelle valeur dans un tableau A
trié dans l’ordre croissant de réel de taille N (Nmax=50).
 1ère méthode : on utilise un deuxième tableau comme tableau résultat.

 2éme méthode : on utilise le même tableau comme tableau résultat.

Q2. En se basant sur le sous-algorithme précédent, écrire un sous-algorithme RemplirTrié
qui insère au fur et à mesure des valeurs saisies par l'utilisateur. L’algorithme s’arrête d’insérer
dans l’un des deux cas :
 L’utilisateur entre la valeur 0.
 Le tableau est entièrement rempli. Dans ce cas afficher un message d’erreur.

D.Cheriti,I.Daoud & L.Ayedi -2-

Algorithmique & Structures de données Travaux Dirigés

Q3. En utilisant les sous-algorithmes précédents, écrire l’algorithme qui permet de :

 Remplir le tableau de réel dans l’ordre croissant,
 Afficher le contenu du tableau.
Exercice N°6 :
Une salle d’attente est représentée par un tableau d’entiers, Salle, contenant les numéros
des clients présents (par exemple leurs numéros de CIN) de taille maximum CAPACITE. La
variable nbClients donne le nombre de clients présents dans la salle d’attente.
Q1. Ecrire un sous-algorithme qui permet d’afficher un menu comme le suivant :
Choisissez l’action à faire :
1  Vérifier salle pleine ou non.
2  Ajouter un client dans la salle d’attente.
3  Faire passer en consultation un client.
4  Vider Salle d’attente

Q2. Si l’utilisateur tape 1 alors il faut afficher VRAI si la salle est pleine, et FAUX sinon.
Ecrire un sous-algorithme PLEINE qui permet de déterminer si la salle est pleine ou non.
Q3. Si l’utilisateur tape 2 alors il faut ajouter un client dans la salle. Si la salle n’est pas
pleine alors :
 Ce nouveau client occupera le premier élément libre du tableau Salle.
 Un message devra indiquer si l’ajout a été possible.
Ecrire un sous-algorithme AJOUTER qui permet de d’ajouter un client dans la salle
d’attente.
Q4. Si l’utilisateur tape 3 alors il faut faire passer en consultation le client le plus
anciennement arrivé dans la salle d’attente.
 Si la salle n’est pas vide alors :
 Un message devra indiquer le numéro du client qui est parti en consultation
c’est le numéro qui occupe la première case du tableau « Salle ».
 On supprime la case Salle[1] en décalant d’un cran (d’une case) vers la gauche
les numéros des clients restants dans le tableau (si la salle n’est pas vide).
 Sinon un message devra indiquer que la salle est vide.
Ecrire un sous-algorithme SUPPRIMER qui permet de supprimer un client de la salle
d’attente.
Q5. Si l’utilisateur tape 4 alors il faut faire passer tous les clients, et afficher, au fur et à
mesure, le numéro des clients qui passent.
Q6. Ecrire l’algorithme qui permet de vider la salle d’attente et ce en utilisant la réponse
de la question précédente.

D.Cheriti,I.Daoud & L.Ayedi -3-

Algorithmique & Structures de données Travaux Dirigés

Corrigé TD5 : Les Types Composés

Partie 1 : Les tableaux

Exercice N°1 :
Q1. Fonction taille() : entier
VAR N :entier
DEBUT
Repeter
Ecrire("Donnez la taille du tableau")
Lire(N)
Jusqu’à (N>0 ET N<=Nmax)
Taille  N
FIN Taille

Q2.
1ère méthode
Procedure RemplirPaire(S T :Tab; E N :entier)
VAR i :entier
Debut
Pour i de 1 à N faire
repeter
Ecrire("T[",i,"]")
Lire(T[i])
Jusqu’à(T[i]>=0 ET T[i]MOD2=0)
Fin Pour
FIN RemplirPaire
2ème méthode
Fonction Parité(X :Entier) :Logique
VAR
Test :Logique Fonction
Debut Parité(X :Entier) :Logique
SI(X MOD 2=0) ALORS Debut
Test  Vrai SI(X MOD 2=0) ALORS
SINON Parité  Vrai
Test  Faux SINON
FIN SI Parité  Faux
Parité  Test FIN SI
FIN Parité FIN Parité

Fonction Parité(X :Entier) :Logique

Debut
Parité  X MOD 2=0 //Retourner(X MOD 2=0)
FIN Parité

D.Cheriti,I.Daoud & L.Ayedi -4-

Algorithmique & Structures de données Travaux Dirigés

Procedure RemplirPaire(S T :Tab; E N :entier)

VAR i :entier
Debut
Pour i de 1 à N faire
repeter
Ecrire("T[",i,"]")
Lire(T[i])
Jusqu’à(T[i]>=0 ET Parité(T[i])
Fin Pour
FIN RemplirPaire
3ème méthode
Fonction VerifParitéPos(X :Entier) :Logique
Debut
Parité  (x>=0 ET X MOD 2=0) //Retourner(X>=0 ET X
MOD 2=0)
FIN Parité
Procedure RemplirPaire(S T :Tab; E N :entier)
VAR i :entier
Debut
Pour i de 1 à N faire
repeter
Ecrire("T[",i,"]")
Lire(T[i])
Jusqu’à(VerifParitéPos(T[i])
Fin Pour
FIN RemplirPaire

Q3. Procedure Afficher (E T: Tab, N : entier)

VAR
i : entier
DEBUT
POUR i de 1 à N FAIRE
ECRIRE(" ",T[i])
FIN POUR
FIN Afficher

Q4. Procedure AffTabInv (E T: Tab, N : entier)

VAR
i : entier
DEBUT
POUR i de N à 1 PAS = -1 FAIRE
ECRIRE(" ",T[i])
FIN POUR
FIN AffTabInv

Q5. Fonction MinTab(T : tab, N : entier) : Entier

VAR
M,i : Entier
DEBUT

D.Cheriti,I.Daoud & L.Ayedi -5-

Algorithmique & Structures de données Travaux Dirigés

M  T[1]
Pour i de 2 à N Faire
Si (T[i] < M) Alors
M T[i]
FinSi
FinPour
MinTab  M //Retourner(M)
Fin MinTab

Q6. 1ère méthode

PROCEDURE Rechercher(E X : Tab, N,P : entier)
VAR
i : entier, Trouve : BOOLEEN
DEBUT
i1
TrouveFAUX
TANT QUE (i <= N ET trouve <> VRAI) FAIRE
SI(X[i]=P) ALORS
ECRIRE("La position de ",P," dans le tableau est ",i)
Trouve VRAI
SINON
ii+1
FIN SI
TANT QUE
SI(Trouve=Faux)ALORS
ECRIRE("Erreur !! ",P," n’existe pas dans le
tableau ")
FIN SI

FIN Rechercher
2ème méthode
PROCEDURE Rechercher(E X : Tab, N,P : entier)
VAR
i : entier
DEBUT
i1
TANT QUE (i <= N ET X[i]<>P) FAIRE
ii+1
FIN TANT QUE
SI(i<=N) ALORS
ECRIRE("La position de ",P," dans le tableau est ",i)
SINON
ECRIRE("Erreur !!",P," n’existe pas dans le tableau")
FIN SI
FIN Rechercher

Q7. Fonction Occurence(T : Tab ; N,P : Entier) : Entier

VAR
i, cpt : Entier

D.Cheriti,I.Daoud & L.Ayedi -6-

Algorithmique & Structures de données Travaux Dirigés

Début
cpt 0
Pour i de 1 à N Faire
Si (T[i] = P) Alors
cpt  cpt + 1
FinSi
FinPour
Occurence  cpt
Fin Occurence
Q8.
1ère méthode
PROCEDURE Inverser(E/S T : Tab; E N :entier)
VAR x,i : entier
DEBUT

POUR i de 1 à (N DIV 2) FAIRE

xT[i]
T[i] T[N-i+1]
T[N-i+1]x
FIN POUR
FIN Inverser
2eme méthode

PROCEDURE Permut(E/S A,B:entier)

VAR
x :entier
DEBUT
xA
A B
Bx
FIN Permut
PROCEDURE Inverser(E/S T : Tab; E N :entier)
VAR x,i : entier
DEBUT

POUR i de 1 à (N DIV 2) FAIRE

Permut(T[i],T[N-i+1])
FIN POUR
FIN Inverser
3ème méthode
PROCEDURE Inverser(E/S T : Tab; E N :entier)

D.Cheriti,I.Daoud & L.Ayedi -7-

Algorithmique & Structures de données Travaux Dirigés

VAR x,i,j : entier

DEBUT
i  1, j N
TANT QUE (i<j)Faire
xT[i]
T[i] T[j]
T[j]x
i i+1, jj-1
FIN TANT QUE
FIN Inverser
Q9.

ALGORITHME TraittementTableau
CONST Nmax=50
TYPE
Tab = tableau [1 .. Nmax] d’entier
VAR
N,j,P : entier
X : Tab
DEBUT
N  Taille()
ECRIRE("********* Remplissage du tableau *********")
Remplir(X,N)
ECRIRE("********* Affichage du tableau *********")

ECRIRE("------> Dans l’ordre de saisie :")

Afficher(X,N)

ECRIRE("------> Dans l’ordre inverse de saisie :")

AffTabInv (X,N)

ECRIRE("Le Minimum du tableau est : ",MinTab(X,N))

ECRIRE("Donnez l’entier : ")

LIRE(P)
j  Occurrence(X,N,P)
ECRIRE("Le nombre d’occurrence de ",P," est ",j)

Inverser(X,N)
ECRIRE("** Affichage du tableau après inversion **")
Afficher(X,N)

FIN
Exercice N°2 :
1ère méthode
PROCEDURE Eclater(E VE : Tab,N:Entier ; S VP, VI : Tab, j,k: Entier)
VAR
i: Entier
DEBUT
j←0,k←0

D.Cheriti,I.Daoud & L.Ayedi -8-

Algorithmique & Structures de données Travaux Dirigés

POUR i de 1 à N FAIRE
SI (VE[i] MOD2 = 0) ALORS
j← j + 1
VP[j]←VE[i]
SINON
k← k + 1
VI[k]←VE[i]
FINSI
FINPOUR
FIN Eclater
2ème méthode
Fonction Parité(X :Entier) :Logique
Debut
SI(X MOD 2=0) ALORS
Parité  Vrai
SINON
Parité  Faux
FIN SI
FIN Parité
PROCEDURE Eclater(E VE : Tab,N:Entier ; S VP, VI : Tab, j,k: Entier)
VAR
i: Entier
DEBUT
j←0,k←0
POUR i de 1 à N FAIRE
SI (Parité(VE[i])= Vrai) ALORS
j← j + 1
VP[j]←VE[i]
SINON
k← k + 1
VI[k]←VE[i]
FINSI
FINPOUR
FIN Eclater

ALGORITHME EclaterTableau
CONST Nmax=50
TYPE
Tab = tableau [1 .. Nmax] d’entier
VAR
N,J,K : entier
VE,VP,VI : Tab

N  Taille()
ECRIRE("********* Remplissage du tableau *********")
Remplir(VE,N)
ECRIRE("********* Affichage du tableau *********")
Afficher(VE,N)

Eclater(VE,N,VP,VI,J,K)

/*affichage des deux tableaux résultats*/

D.Cheriti,I.Daoud & L.Ayedi -9-

Algorithmique & Structures de données Travaux Dirigés

ECRIRE("***** Affichage du tableau des paires ****")

Afficher(VP,J)

ECRIRE("**** Affichage du tableau des impaires ****")

Afficher(VI,K)

FIN
Exercice N°3 :
Q1.
PROCEDURE Remplir(S Reponse : Tab ;E N :entier)
DEBUT
Pour i de 1 à N Faire
repeter
Ecrire("Donnez le caractère N°",i)
Lire(Reponse[i])
Jusqu’à(Majus(Reponse[i])>='A' ET Majus(Reponse[i])<='Z')
FinPour
Fin Remplir

Q2.
PROCEDURE Corriger(E/S Reponse : Tab ; S nb : Entier, E N:Entier)
DEBUT
nb 0
Pour i de 1 à N Faire
Si (Majus(Reponse[i]) <> CHR(i+(ORD('A')-1))) Alors
Reponse[i]CHR(i+(ORD('A')-1))
nb nb + 1
FinSi
FinPour
Fin Corriger
PROCEDURE Corriger(E/S Reponse : Tab ; S nb : Entier, E N:Entier)
VAR
TC :Tab
DEBUT
// initialisation du tableau
TC {‘A’,’B’,’C’…}//1ere methode
Pour i de ORD('A') à ORD('Z') FAIRE // 2eme methode
TC[i]  CHR(i)
FIN POUR
/////////////////////////////////
nb 0
Pour i de 1 à N Faire
Si (Majus(Reponse[i]) <> TC[i]) Alors
Reponse[i] TC[i]
nb nb + 1
FinSi
FinPour
Fin Corriger

Q3.
ALGORITHME Alphabet
CONST N = 26
TYPE Tab = Tableau[1..N] de Car
VAR

D.Cheriti,I.Daoud & L.Ayedi - 10 -

Algorithmique & Structures de données Travaux Dirigés

reponse : Tab
nbF : Entier
DEBUT
remplir(reponse,N)
corriger(reponse, nbF, N)
Ecrire("Nombre de fautes : ",nbF)
Fin
Exercice N°4 :
Q1.
FONCTION EstTrié(T :Tab, N :entier) :Logique
VAR i : entier, Trier : Logique
DEBUT
i1
Trier Vrai
TANT QUE ((i<= N-1) et Trier=VRAI) FAIRE
SI(T[i]< T[i+1])ALORS
ii+1
SINON
TrierFaux
FIN SI
FIN TANT QUE
EstTrié  Trier
FIN EstTrié
Q2.
PROCEDURE Fusion(E V1 : Tab, V2 : Tab, N :entier ;M :entier ; S V3
:TabF; k :entier)
VAR i, j: Entier
DEBUT
i 1, j 1, k0
TANTQUE (i <= N) ET (j <= M) FAIRE
SI (V1[i] <= V2[j]) ALORS
kk + 1
V3[k]V1[i]
ii + 1
SINON
kk + 1
V3[k]V2[j]
jj + 1
FINSI
FINTQ
TantQue (i <= N) FAIRE
kk + 1
V3[k]V1[i]
ii + 1
FINTQ
TANTQUE (j <= M) FAIRE
kk + 1
V3[k]V2[j]
jj + 1
FINTQ

D.Cheriti,I.Daoud & L.Ayedi - 11 -

Algorithmique & Structures de données Travaux Dirigés

FIN Fusion

ALGORITHME TableauFusion
CONST
Nmax=50
TYPE
Tab =tableau [1 .. Nmax] d’entier
TabF =tableau [1 .. 2*Nmax] d’entier
VAR
N,M,K : entier
trier : Logique
V1,V2: Tab
V3 :TabF
DEBUT
N  Taille()
ECRIRE("****** Remplissage du tableau N°1 *******")
Repeter
Remplir(V1,N)
Jusqu’à(EstTrié(V1,N))
ECRIRE("****** Remplissage du tableau N°2 *******")
M  Taille()
Repeter
Remplir(V2,M)
Jusqu’à(EstTrié(V2,M))
Fusion(V1,V2,N,M,V3,K)
ECRIRE("******** Affichage du tableau N°1 ********")
Afficher(V1,N)
ECRIRE("******** Affichage du tableau N°2 ********")
Afficher(V2,M)
ECRIRE("******** Affichage du tableau N°3 ********")
Afficher(V3,K)
FIN

Exercice N°5 :
Q1. { on ne considère pas les cas où le tableau est vide ou plein)
1ere méthode :
Procédure InsereVal_1 (E A:Tab,R:Entier,N :Entier ;S B : Tab)
VAR i, j : Entier
DEBUT
i  1,j  1
TantQue (A[i] <= R) et (i <= N) Faire
B[j]  A[i]
i i + 1, j j + 1
FinTQ
B[j]  R
j j + 1
TantQue (i <= N) Faire
B[j]  A[i]
ii + 1, j j + 1
FinTQ
FIN InsereVal_1

D.Cheriti,I.Daoud & L.Ayedi - 12 -

Algorithmique & Structures de données Travaux Dirigés

2éme méthode :
Procédure InsereVal_2 (E/S A : Tab, N :entier,E R : entier )
VAR
i : Entier
DEBUT
i  N+1
TANT QUE (i > 0 et A[i-1] > R) FAIRE
A[i]  A[i-1]
i  i-1
FIN TQ
A[i]  R
N  N + 1
FIN InsereVal_2
Q2.
Procédure RemplirTrié(E/S A : Tab, N : Entier)
VAR
V,i : entier
DEBUT
i  0
REPETER
Ecrire("Donnez une valeur réel")
LIRE(V)
SI (V ≠ 0) ALORS
SI (i=0) ALORS //tableau vide
T[1]  V
i  i+1
SINON SI (i<Nmax) ALORS
InsereVal_2(T,V,i)
SINON
Ecrire("Le tableau est plein!! Impossible
d’ajouter un nouvel élément.")
FIN SI
FIN SI
SINON
Ecrire("Fin du remplissage du tableau.")
FIN SI
JUSQU’A (i=Nmax ou V=0)
N  i
FIN RemplirTrié
Q3.
ALGORITHME Remplir_Tableau_trié
CONST Nmax=50
TYPE
Tab= tableau [1 .. Nmax] de réel
VAR
N : entier
T : Tab
DEBUT
RemplirTrié(T,N)
Afficher(T,N)
FIN

D.Cheriti,I.Daoud & L.Ayedi - 13 -