Salam, j’ai essayé de mettre le maximum des exercices des examens passés,

certains existent déjà dans les séries d’exercices donc j’ai préféré ne pas les
mettre, essayez de faire les exercices en groupes en respectant la durée
maximale que j’ai mis.
« Bon courage »
Exercice 2 : (rattrapage 2014)=25min
Écrire un algorithme qui crée une liste chaînée L de n entiers (n>0), puis utilise une
procédure pour supprimer tous les éléments multiples du premier élément de la liste.
Afficher la liste finale.
Exemple :
L
2 8 1 9 5 4 3 6 12 7

L 2 1 9 5 3 7

Exercice 1 : (Examen 2015) =25min

- Etant donnés deux nombres entiers x, y. Ecrire un sous algorithme qui vérifie si la
fraction x/y est un nombre entier ou non.
Exemples : si x=3 et y=2 alors x/y=2.5 donc ce n’est pas une fraction entière
si x=8 et y=2 alors x/y=4 donc c’est une fraction entière.
- Ecrire un algorithme qui lit deux tableaux d’entiers T1, T2 de même taille n (0<n<=50),
puis utilise le sous algorithme précédant pour afficher le nombre de fractions entière entre
les deux tableaux. (c'est-à-dire le nombre de fractions T1[i]/T2[i] qui sont entières)
Exemple :
T1 -4 0 3 7 8 4 1 3
T2 2 1 0 4 -1 5 7 9
oui oui non non oui non non non
Ici il y a 3 fractions entières.
Attention : il ne faut surtout pas divisé sur 0.

Exercice 2 : (Examen 2015) =25min (Attention à l’enchainement des questions)

Ecrire un algorithme qui permet de :
- Définir le type Liste.
- Créer une liste d’entiers chainée d’entiers L, l’arrèt se fera dès la lecture de 5 nombres
impairs (la liste se termine par le 5ème nombre impair).
- Puis, relier (chainer) le dernier élément avec le premier élément.
- Et enfin, calculer et afficher la moyenne des éléments de la liste L.

Exercice 3 : (Examen 2015) =25min

2- Ecrire une fonction qui vérifie si deux piles d’entiers non vides P, Q sont anagrammes ou non.
Deux piles sont anagrammes s’il contient les mêmes éléments mais dans un ordre différent.
Exemples : P et Q sont anagrammes, mais P et R ne sont pas anagrammes

0 3 0
0 2 2
3 0 0
3 3 0
2 0 3
P Q R

Page 1 sur 10
 Exercice 1 : (Rattrapage 2015) =25min
- Soit A une matrice d’entiers de taille (n, m) avec n<=20 et m<=30 et B une autre matrice
d’entiers de taille (p, q) avec p<=20 et q<=30. Ecrire une fonction Est_Transpos qui
vérifie si la matrice B est la transposée de A ou non.
Rappel : B est la transposé de A si p=m et q=n et chaque ligne i de A est la colonne i dans B.
- Ecrire un algorithme qui lit les deux matrices A et B puis appel la fonction
Est_Transpos pour afficher si B est la transposé de A ou non.

Exercice 2 : (Rattrapage 2015) =30min les questions sont indépendantes

1. Ecrire la procédure Empiler (vue en cours).
2. Soit P une pile d’entiers non vide. Ecrire une fonction qui vérifie si la pile P est sans
répétition (c'est-à-dire, on ne trouve pas une valeur qui existe deux fois ou plus)
Remarques :
- Vous ne devez pas remettre les éléments de P.
- Il est strictement interdit d’utiliser les tableaux.

Exercice 3 : (Rattrapage 2015) =30min

Etant donnée une liste non vides L.
1. Ecrire un sous-algorithme vider(L) qui supprime tous les éléments de L (la liste devient
vide).
2. Ecrire un sous-algorithme ajouterAvant(x, y, L) qui insert une valeur x dans la liste L avant
la première occurrence d’une valeur y. (x, et y étant deux nombres entiers)
Exemple : x=10, y=5 L=135250
après insertion : L=113105250

Exercice 1 : (Examen 2016) =30min

Ecrire une fonction NB_Occ qui calcul le nombre d’occurrence d’un caractère c donné dans
une chaine de caractères ch de taille n (n<=100).
Ecrire un algorithme qui :
- Lit deux chaines de caractères ch1, ch2 de tailles respectives n1, n2 (n1<=100, n2<=100).
- En utilisant la fonction NB_Occ, vérifie si ch1 et ch2 sont anagrammes ou non.
Rappel : deux chaines ch1 et ch2 sont anagrammes s’ils ont la même taille et le nombre
d’occurrence de chaque caractère de ch1 et le même pour les deux chaines

Exemples :
ch1=“aab” et ch2=”aba” sont anagrammes.
Mais : ch1=”babaa” et ch2=”bbaba” ne sont pas anagrammes. Car le nombre d’occurrence de
‘a’ dans ch1 est 3, mais le nombre d’occurrence de ‘a’ dans ch2 est 2.

Exercice 1 : (Rattrapage 2016) =25min

Etant donnée une matrice carrée d’entiers A de taille n (n≤20) et un sous algorithme
VERIF qui vérifie si deux colonnes p et q sont identiques ou non.
Ecrire un algorithme (avec le sous algorithme VERIF) qui lit la matrice A et utilise le
sous algorithme VERIF pour vérifier si A est une matrice symétrique vertical.
Remarque : Une matrice carrée est dite symétrique vertical, si les colonnes sont
symétriques, c’est-à-dire la 1ère colonne = la nème colonne, et la 2ème colonne = la (n-1)ème
colonne ...
Exemple : n=5, A est symétrique vertical
A 1 2 3 2 1
2 3 0 3 2
4 4 5 4 4
5 1 2 1 5
0 3 0 3 0

Page 2 sur 10
Exercice 3 : (Rattrapage 2016) = 30min
Etant donnée une liste non vide L, ne contenant que des valeurs strictement positives. Ecrire
un sous algorithme qui :
1/ Supprime à partir de L les valeurs impairs et les met dans une nouvelle liste S.
2/ Affiche les éléments de S.

Exemple :
L 3 4 7 2 3 6

L 3 4 7 2 3 6

L 4 2 3 6 S4 3 2 7

Page 3 sur 10
Solution Exercice 2 : (rattrapage 2014)
Algorithme Listemultiple ;
Type MaillonL=structure
valeur : entier ;
Suivant :^(MaillonL) ;
fin
Variable
L, p : ^(MaillonL) ; n, x : entier ;

{Suppression des éléments multiples du premier élément}

Procedure sup(var L :^(MaillonL), n:entier) ;
Variable y:entier ; p, q: ^(MaillonL) ;
pL ;
qp^.suivant ;
yp^.valeur ;
pour i2 à n faire (ou bien Tant que(q<>Nil) ou tantque(p^.suivant <>nil))
Si (q^.valeur ) mod y =0 alors
p^.suivant q^.suivant;
liberer(q) ;
qp^.suivant ;

sinon qq^.suivant ;
pp^.suivant ;
finsi ;
Fait ;
Fin

Début
Ecrire(“Donner la taille de la liste“) ; Lire(n) ;

{création de la liste}
{1ère méthode} {2ème méthode}
LNil ; LNil ;
Pour i1 à n faire Pour i1 à n faire
Ecrire(“Donner un entier“) ; Ecrire(“Donner un entier“) ;
Lire(x) ; Lire(x) ;
Allouer(p) ; Allouer(p) ;
p^.valeurx ; p^.valeurx ;
p^.suivantL ; Si(L=Nil) alors Lp ;
Lp ; Sinon q^.suivantp ;
Fait; Finsi ;
qp ;
Fait ;
q^.suivantNil ;

{Appeler la procédure}
sup(L,n) ;

{Affichage de la liste après suppression}

pL ;
Tant que(p<>Nil) faire
Ecrire(p^.valeur) ;
pp^.suivant ;
Fait ;
Fin

Page 4 sur 10
Solution Exercice1 : (Examen 2015)
Algorithme exo1 ;
Variable T1, T2 : Tableau [50] entier ; n, i : entier
Fonction fraction_entière (x : entier, y : entier) : booléen ;
Début
Si (x mod y =0) alors fraction_entièrevrai ;
Sinon fraction_entièrefaux ;
Finsi ;

{ou alors fraction_entière x mod y =0 ;}

Fin
DEBUT
Ecrire(“Donner n entre 1 et 50“) ; Lire(n) ;
Pour i1 à n faire
Ecrire(“donner un élément de T1“) ; Lire(T1[i]) ;
Ecrire(“donner un élément de T2“) ; Lire(T2[i]) ;
Fait ;

cpt0 ;
Pour i1 à n pas 1 faire
Si(T2[i]<>0 et fraction_entière(T1[i], T2[i])=vrai) alors
cptcpt+1 ;
Finsi ;
Fait ;
Ecrire(cpt) ;
Fin

Solution Exercice 2 : (Examen 2015)

Algorithme ListeEntiers ;
Type MaillonL=Enregistrement
Valeur : entier ;
Suivant : ^MaillonL ;
Fin ;
Variable
p, q, L : ^MaillonL ; nb, cpt : entier ;
Début
{création de la liste}
LNil ;
nb0 ;
Tant que (nb<5) faire
Allouer(p) ;
Ecrire(“donner un nombre entier“) ;
lire(p^.valeur) ; {ou alors : lire(x) ; p^.valeurx ;}
si (P^.valeur mod 2 <>0) alors nbnb+1 ; finsi ;

Si(L=Nil) alors Lp ; qp ;

Sinon q^.suivantp ; qp ;
Finsi ;
Fait ;
q^.suivantNil ;

{Relier le dernier avec le premier}

pL ;
Tant que(p^.suivant<>Nil) faire pp^.suivant ; Fait ;
P^.suivantL ;

Page 5 sur 10
{caluler la moyenne}
{1ère méthode} {2ème méthode}
SL^.valeur ; cpt1 ; S0 ; PL ; cpt1 ;
PL^.suivant ; Tant que (P^.suivant<>L) faire
Tant que (P<>L) faire SS + p^.valeur ;
SS + p^.valeur ; pp^.suivant ;
pp^.suivant ; cptcpt+1 ;
cptcpt+1 ; Fait ;
Fait ; SS + p^.valeur ;
MoyS/cpt ;
Ecrire(“la moyenne est :“, Moy) ;
Fin

Solution Exercice 3 : (Examen 2015)

2- Fonction anagramme(var P : ^ MaillonP, var Q: ^ MaillonP) ;
Variable R : ^ MaillonP ; x : entier ; anag : booléen ;
Début
{initialisation de R et anag}
InitPile(R) ; anagvrai ;
Tantque (PileVide(P)=faux et anag=vrai) faire
{rechercher dans Q le sommet de P}
Tant que(PileVide(Q)=faux et SommetPile(Q)<>SommetPile(P)) faire
Dépiler(Q, x) ; Empiler(R, x) ;
Fait ;
{cas sommet de p n’existe pas dans q => non anagrammes}
Si(Pilevide(Q)=vrai) alors anagfaux ;
Sinon {un sommet de p existe dans q alors dépiler les deux}
Dépiler(P, x) ; Dépiler(Q, x) ;
Finsi ;
{Remettre le reste des éléments de R dans Q}
tant que(PileVide(P)=faux) faire
Dépiler(R, x) ; Empiler(Q, x) ;
Fait ;
Fait ;
Anagrammeanag ;
Fin

Solution Exercice 1 : (Rattrapage 2015)

Fonction Est_Transpos (A : tableau[20, 30]entier, n: entier, m: entier,
B : tableau[20, 30]entier, p : entier, q : entier) : booléen ;
Variable i, j : entier ; tr : booléen ;
Début
Si (n<>q ou m<>p) alors Est_Transpos faux ;
Sinon
trvrai ; i1 ;
Tantque (i<=n et tr=vrai) faire
j1 ;
Tantque(j<=m et tr=vrai) faire
Si A[i, j]<>B[j, i] alors trfaux ; finsi ;
jj+1 ;
Fait ;
ii+1 ;
fait ;
Est_Transpos tr ;
Finsi ;
Fin
Page 6 sur 10
DEBUT
Répéter Ecrire(“donner n entre 1 et 20 et m entre 1 et 30“) ; lire(n, m) ;
Jusqu’à (n>0 et n<=20 et m>0 et m<=30) ;
Pour i1 à n pas 1 faire
Pour j1 à m pas 1 faire
Ecrire(“Donner un élément de A“) ; Lire(A[i, j]) ;
Fait ;
Fait ;
Répéter Ecrire(“donner p entre 1 et 20 et q entre 1 et 30“) ; lire(p, q) ;
Jusqu’à (p>0 et p<=20 et q>0 et q<=30) ;
Pour i1 à p pas 1 faire
Pour j1 à q pas 1 faire
Ecrire(“Donner un élément de B“) ; Lire(B[i, j]) ;
Fait ;
Fait ;

Si (Est_Transpos(A, n, m, B, p, q)=vrai) alors

Ecrire (“la matrice B est la transposée de A“) ;
Sinon Ecrire(“B n’est pas la transposée de A “) ;
Finsi ;
FIN

Solution Exercice 2 : (Rattrapage 2015)

1) Procédure Empiler(var Sommet: ^ MaillonP, e : entier);
Variable p : ^ MaillonP ;
Début
Allouer(P) ; P^.valeure ;
p^.suivant Sommet; Sommetp ;
Fin

2) Fonction Sans répétition(P : ^MaillonP) :booléen ;

Variable x, y : entier ;
Début
srvrai ;
Tantque (non pilevide(P) et sr=vrai) faire
Dépiler (P, x) ;
Tantque(non pileVide(P) et sr=vrai) faire
Si(SommetPile(P)=x) alors srfaux ;
Sinon Dépiler (P, y) ; Empiler(Q, y) ;
Finsi ;
Fait ;
Tantque(non pileVide(Q)) faire
Dépiler(Q, y) ; Empiler(P, y) ;
Fait ;
Fait ;
Sans répétitionsr ;
Fin

Solution Exercice 3 : (Rattrapage 2015)

1) Procédure Vider(var L : ^MaillonL) ;
Variable P :^MaillonL ;
Début
Tantque (L<>Nil) faire
PL ; LL^.suivant ; Libérer(P) ;
Fait ;
Fin
Page 7 sur 10
2) Procédure ajouterAvant (x : entier, y : entier , L : ^ MaillonL);
Variable s, p, q : ^ MaillonL ;
début
si (L^.valeur=y) alors Allouer(s) ; s^.valeurx ; s^.suivantL ; Ls ;
Sinon pL ;
Tant que(p<>NIL et p^.valeur <> y) faire
qp ; p p^.suivant;
fait ;
Si(p=Nil) alors ecrire(“insertion impossible : “, y, “n'existe pas");
Sinon
Allouer(s) ; s^.valeur x ;
s^.suivant p; q^.suivant s ;
finsi ;
finsi ; fin

Solution Exercice 1 : (Examen 2016)

Algorithme exo1 ;
Variable ch1, ch2 : tableau[100]caractère ;
n1, n2, i : entier ; anag : booléen ;
Fonction NB_Occ(ch : tableau[100]caractère, n : entier, c : caractère) : entier;
Variable i, cpt : entier ;
Début
cpt0 ;
pour i1 à n pas 1 faire
si(ch[i]=c) alors cptcpt +1; finsi ;
fait ;
NB_Occcpt ;
Fin
DEBUT
Ecrire(”Donner deux chaines de caractères : ”); Lire(ch1, ch2) ;
n1Longueur(ch1) ; n2Longueur(ch2) ;

si(n1<>n2) alors Ecrire(”ch1 et ch2 ne sont pas anagrammes”) ;

sinon
anagvrai ; i1 ;
tant que(i<=n1 et anag=vrai) faire
Si(NB_Occ(ch1, n1, ch1[i])<> NB_Occ(ch2, n2, ch1[i])) alors anagfaux ;
Sinon ii+1 ;
Finsi ;
fait ;
si(anag=faux) alors Ecrire(”ch1 et ch2 ne sont pas anagrammes”) ;
sinon Ecrire(”ch1 et ch2 sont anagrammes”) ;
finsi ;
finsi ;
FIN

Solution Exercice 1 : (Rattrapage 2016)

Algorithme exo1 ;
Variable A : tableau[20, 20]entier ;
n, i, j : entier ; sym : booléen ;
Fonction VERIF (A : tableau[20, 20]entier, n : entier, p : entier, q :entier) : booléen ;
Variable i : entier ; id :booléen ;
Début
idvrai ;
i1 ;
Page 8 sur 10
tant que(i<=n et id=vrai) faire
si(A[i, p]<>A[i, q]) alors idfaux ;
sinon ii+1 ;
finsi ;
Fait ;
VERIFid ;
Fin
DEBUT
Répéter
Ecrire(”Donner n entre 1 et 20 : ”) ; lire(n) ;
Jusqu’à(n>0 et n<=20) ;

Pour i1 à n pas 1 faire

Pour j1 à n pas 1 faire
Ecrire(”Donner un élément : ”) ; lire(A[i, j]) ;
Fait ;
Fait ;

symvrai ;
jn ; i1 ; i1 ;
Tant que(i<=n div2 et sym=vrai) faire Tant que(i<n div2 et sym=vrai) faire
Si non (VERIF(A, n, i, j)) alors Si non (VERIF(A, n, i, n-i+1)) alors
symfaux ; symfaux ;
Sinon ii+1; jj-1; Sinon ii+1 ;
Finsi ; Finsi ;
Fait ; Fait ;
jn ; i1 ; jn ; i1 ;
Tant que(i<n div2 et sym=vrai) faire Tant que(i<j et sym=vrai) faire
Si non (VERIF(A, n, i, j)) alors Si non (VERIF(A, n, i, j)) alors symfaux ;
symfaux ; Sinon ii+1; jj-1;
Sinon ii+1; jj-1; Finsi ;
Finsi ; Fait ;
Fait ;

Si(sym=vrai) alors Ecrire(”la matrice A est symétrique vertical ”) ;

Sinon Ecrire(”la matrice A n’est pas symétrique vertical ”) ;
Finsi ;
FIN

Solution Exercice 3 : (Rattrapage 2016)

Procédure Liste_Pair_Impair (var L : ^MaillonL, var S : ^MaillonL) ;
Variable p, q, r, t : ^MaillonL ;
Début
{Supprimer les valeurs impaires de L et les mettre dans S}
SNil ; {initialiser la tête de la nouvelle liste}
pL ; {p : élément à tester dans L, et q : précédant de p}
Tant que (p<>Nil) faire
Si(p^.valeur MOD 2 <>0) alors
{Traitement de l’insertion dans la liste S}
Allouer(t) ; t^.valeurp^.valeur ; {t : nouveau maillon, et r : dernier maillon}

Si(S=Nil) alors St ;

Sinon r^.suivantt ;
Finsi ;
rt ;

Page 9 sur 10
 {Traitement de la suppression dans la liste L}
Si(p=L) alors {cas : suppression au début}
LL^.suivant ; Libérer(p) ; pL ;
Sinon {cas : suppression après le premier}
q^.suivantp^.suivant ; Libérer(p) ; pq^.suivant ;
Finsi ;
Sinon qp ; pp^.suivant ;
Fini ;
Fait ;

pS ;
tant que(p<>Nil) faire
Ecrire(p^.valeur) ;
pp^.suivant ;
fait ;
Fin

Page 10 sur 10