Série 2: Algo

ACAD A 2021/2022

Mme F OUAZAR LOUNNACI

Exercice 1
 1 Calculer la somme des N premiers entiers naturels pairs:
0+2+4+…+2N.
Fonction SomPair(N :entier) :entier
Déroulement
Debut N=5 (SomPair(5))
Si N=0 Alors 8+SomPair(4)
8+6+SomPair(3)
Retourner 0 //cas trivial 8+6+4+SomPair(2)
Sinon 8+6+4+2+SomPair(1)
8+6+4+2+0+SomPair(0)
retourner 2*(N-1)+SomPair(N-1) N=0 (arrêt des appels récursifs)
SomPair(5)=0+0+2+4+6+8=20
Fsi ;
Fin ;
 2- Afficher les N premiers entiers naturels impairs par ordre
croissant.
Procedure AffImpCroi(E/ N :entier) ;
Debut
Si N<>0 Alors
AffImpCroi(N-1) ; //affichage croissant, tous les appels après l’affichage
au retour (récursivité non terminale)
Ecrire(2*N-1) ;
Fsi ;
Fin ;
Pour un ordre décroissant on écrit d’abord après on fait appel à la
procédure affichage (récursivité terminale)
 3- Afficher les N premiers entiers naturels multiples de 3 par
ordre décroissant.
Procedure AffMulti3Dec(E/ N :entier) ;
Debut
Si N<>0 Alors
Ecrire(3*(N-1)) ;
AffMulti3Dec (N-1) ;
Récursivité terminale
Fsi ;
Fin ;
 4- Afficher le nombre de chiffres pairs dans un entier N.

Fonction NBCfPair(N :entier) :entier ;

Var Chiff :entier ;
Debut
Chiff N mod 10 ;
Si N div 10>0 Alors
Si (Chiff mod 2 =0)Alors
NBCfPair1+ NBCfPair(N div10) ;
Sinon NBCfPairNBCfPair(N div10) ;
Fsi ;
Sinon Si (Chiff mod 2 =0) Alors
NBCfPair1
Sinon NBCfPair0
Fsi ;
Fsi ;
Fin ;
Pour l’affichage du nombre de chiffres pair on appelle la fonction NBCfPair(N)
dans le programme principal avec ecrire(NBCfPair(N))
 5- Calculer ab, a et b étant des entiers non négatifs.

Fonction Puissance(a, b :entier) entier

Debut
Si b=0 Alors
Retourner 1
Sinon
Retourner a*Puissance(a,b-1)
Fsi
Fin
Les cas d’erreurs comme a=0 , on les test dans le l’algorithme
avant l’appelle de la fonction
Exercice 2: tableau trié dans l’ordre
decroissant
Fonction RechSeq(T[100] ; N,i,Val:entier): Booleen ;
Debut
Si i>=n ou Val>T[i] Alors //on peut ajouter ou T[n-1]<Val
Retourner Faux
Sinon Si le tableau n’est pas
trié on supprime le
Si T[n] =Val Alors test (ou Val>T[i]
Retourner vrai
Sinon
Retourner RechSeq(T,N,i+1,Val)
Fsi
Fsi ;
Fin ; // le premier appel de la fonction se fait avec i=0
Recherche dichotomique
Fonction RechDicho(T [100],ideb,ifin,Val:entier): Booleen ;
Var entier M ;
Debut
Si ideb>ifin Alors
retourner faux//debut > Fin
Sinon M(ideb+ifin) DIV 2; //milieu
Si T[M] =Val Alors
Retourner vrai
Sinon
Si T[M]>Val Alors
retourner RechDicho(T,M+1,ifin,Val)
Sinon
retourner RechDicho(T,ideb,M-1,Val)
Fsi
Fsi
Fsi ;
Fin ;
Eercice 3
 1. Vérifier si un mot M donné de longueur n est un palindrome ou non.
Fonction Palindrome(car M[100] ;entier: deb,fin) :booleen;
Debut
Si deb ≥ fin Alors
Retourner vrai
Sinon
Si M[deb]=M[fin] Alors
Retourner Palindrome(M,deb+1,fin-1)
Sinon
Retourner faux
Fsi ;
Fsi ;
Fin ;
2. Vérifier si un mot M2 est sous-mot d’un mot M1 donné.
N1:taille de M1
N2: taille de M2
Fonction sousMot ( char M1[30],M2[30]; entier: i, j, N1, N2 )booléen
Debut
si (j = N2 ) alors retourner (vrai); //cas trivial inutile de continuer car il
sinon ne reste pas assez de
si (i > N1-N2-j) alors retourner (faux); //cas trivial caractères dans M1 pour
sinon les comparer avec M2
si (M1[i] = M2[j]) alors //continuer la recherche des autres caractères
retourner (sousMot (M1, M2, i+1, j+1, N1, N2)); // appel récursif
sinon //M1[i] <>M2[j]
retourner (sousMot (M1, M2, i-j+1, 0, N1, N2)); // appel récursif
Fsi; il faut revenir à 0 dans M2 et à l’indice i-j+1 dans M1 et relancer la
fonction sousMot.
Fsi;
Fsi
Fin;
3. Vérifier si deux mots m1, m2 sont identiques.
Fonction identique(char m1[40], m2[40],i,n) booléen
Debut
Si i>=n alors
Retourner vrai //les deux mot sont identiques
Sinon
si m1[i]<>m2[i] alors
retourner faux
sinon
retourner identique(m1,m2,i+1,n) //relancer la verification
fsi
Fsi
Fin
 Exercice 4 (les listes)
 1. Ecrire une action paramétrée Insère qui insère une valeur
X donnée dans une liste triée de nombres réels.
Déclaration de la liste
Type Liste = ptr Elément;
Elément = Enregistrement
info: réel;
svt: ptr Elément;
FinEnreg;
ProcédureINSERE (E/S tete:Liste, E/ x:réel )
Var
p, q, r : Liste;
Debut
// créer l’élément
p allouer (tailleDe(Element));
Cont(p).info x;
// Cas d’une insertion en tête de liste
si (x < cont(tete).info)
alors cont(p).svt tete; tetep;
sinon // parcourir la liste pour trouver la position d’insertion
q tete;
Tant que (q<>nil et cont(q).info < x)
faire r q ; q cont(q).svt ;
fait;
// r permet de sauvegarder l’adresse de l’élément précédent
// à la sortie de la boucle, p sera inséré entre r et q
Cont(r).svt p ;
cont(p).svt q ;
Fin;
2. Ecrire une action paramétrée qui lit n réels et les range dans une liste de
point d’entrée T, de telle sorte que la liste soit triée à chaque étape.

 On va créer l’élément de tête

 Pour tous les autres éléments, appeler la procédure Insère
pour insérer les éléments dans l’ordre croissant
Fonction ConstListeTriée(n: entier): Liste
Var
tete: Liste;
x: réel;
i: entier;
Debut
// créer le 1erélément
teteallouer (tailleDe(Element));
Ecrire (" Donnez une valeur x "); lire (x);
Cont(tete).info x;
Cont(tete).svt nil;
// insertion des autres éléments
pour i 2 à n faire
Ecrire (" Donnez une valeur x ");
lire (x);
Insere(tete, x);// appel de la procédure Insère
fait;
Retourner (tete);
Fin;
 3. Ecrire une fonction qui fusionne deux listes T1 et T2 de
réels, triées par ordre croissant.

La méthode: Comparer les deux éléments des têtes de liste et placer la tête T sur la plus
petite valeur.
Parcourir les éléments restants dans T1 et T2 et les comparer deux à deux:
Si l’élément de la liste T1 est plus petit, on l’enchaine avec les éléments qui sont déjà dans T et on
avance dans T1.
Si l’élément de la liste T2 est plus petit, on l’enchaine avec les éléments qui sont déjà dans T et
avance dans T2.
A la fin, il restera des éléments dans T1 ou dans T2, il faudra faire un seul chainage
pour les ajouter à la liste T
Fonction FusionTriée(E/ T1, T2:
Liste ): Liste // parcourir les deux listes en même temps et comparer les
Var éléments deux à deux
T, p1, p2, p, q : Liste; // p1 pour Tant que ( p1 <> nil et p2 <> nil)
parcourir T1 et p2 pour parcourir T2 faire
Debut// q sera toujours sur le dernier si (cont(p1.info )< cont(p2.info))
élément ajouté à la liste T alors cont(q.svt)p1; q p1; p1cont(p1.svt);
// on avance dans T1
si (T1 = nil) alors TT2;
sinon cont(q.svt)p2; q p2; p2cont(p2.svt);
sinon si (T2 = nil) alors TT1; // on avance dans T2
sinon fsi;
// placer l’élément de tête fait;
si (cont(T1.info) < cont(T2).info) // Il reste des éléments dans l’une des listes T1 ou T2
alors TT1; p1cont(T1).svt; si( p1 <> nil)// éléments restants dans T1
alors cont(q.svt)p1;
sinon TT2; p2cont(T2).svt;
sinon cont(q.svt)p2; // éléments restants dans T2
Fsi Fsi
qT; Fsi;
Retourner (T);
Fin;
 4. Ecrire une action paramétrée qui éclate une liste T (non ordonnée)
de réels en deux listes T1 et T2 triées par ordre croissant de telle sorte
que T1 contienne les valeurs >= X et T2 contienne les valeurs <X pour
une valeur X donnée.

Méthode : on écrit une procédure ajout pour ajouter un élément déjà crée en utilisant son adresse
puis une autre procédure éclate pour parcourir T, on vérifie la valeur, si elle est >=X on appelle la
procédure ajout pour l’inserer dans T1 sinon on l’insere dans la liste T2 avec la procédure ajout
Procédure Ajout (E/S tete: Liste, E/ p:Liste)
Var
p, q, r : Liste;
Debut
// si la liste est vide
si (tete= nil)
alors tetep;
sinon
si cont(p.info )< cont(tete.info) // insertion en tête
alors cont(p.svt)tete; tetep;
sinon // parcourir la liste pour trouver la position d’insertion
q tete;
Tant que (q<>nil et cont(q.info) < cont(p.info)
faire r q ; q cont(q.svt)
fait
// r permet de sauvegarder l’adresse de l’élément précédent
// à la sortie de la boucle, p sera inséré entre r et q
Cont(r.svt)p ; cont(p.svt)q ;
Fin;
Procédure Eclate (E/S T, T1,T2: liste, E/X: entier)
Var
p, q : Liste;
Debut// initialiser T1 et T2 à nil
T1 nil; T2 nil;
// parcourir la liste T
p T;
Tant que (p<>nil) faire
q cont(p.svt); // pour continuer le parcoursavec l’élément suivant
Cont(p.svt)nil;// détacher l’élément courant de liste T
si (cont(p.info) >= X)
Alors Ajout (T1, p); // ajouter l’élément dans T1
Sinon Ajout (T2, p); // ajouter l’élément dans T2
fsi;
pq; // on sera sur l’élément suivant de la liste T
fait;
Tnil;
Fin;
 Exercice 5
1. Ecrire une fonction BINAIRE qui décompose un nombre entier
positif x en binaire, dans une liste chaînée bidirectionnelle.

Exemple :
X=11

Déclaration

Type ListeBD= Enregistrement

tete, queue : ptr Elément;
FinEnreg;
Elément = enregistrement
info: entier;
svt: ptr Elément;
prd: ptr Elément;
FinEnreg;
Fonction Binaire (E/ X: entier): ListeBD
Var
L: ListeBD; p: ptr Elément;
Debut
L.tetenil; L.queuenil;
Répéter
p allouer (tailleDe(Element));
Cont(p.info) Xmod 2 ; X Xdiv2;
si(L.tete<> nil) alors cont(L.tete).prdp;
fsi;
Cont(p.svt)L.tete; L. tetep;
si (L.queue= nil) alors L.queuep; fsi;
// 1er élément créé qui se retrouve à la fin de la liste
Jusqu’à (X = 0)
cont(L.tete).prdnil; Retourner (L);
Fin;
Les restes de la division seront stockés dans le sens inverse
Donc création LIFO de la liste
 2. Ecrire une fonction PAIR qui vérifie si le nombre
représenté par la liste est pair (sans le calculer).

Fonction Pair (E/ L: ListeBD): booléen

Debut
si(cont(L.queue).info = 0) alors retourner(vrai);
sinon retourner(faux);
Fsi;
Fin;
Il suffit de vérifier la valeur du bit le plus à droite
(queue de la liste), s’il est à zéro c’est un nombre
pair sinon c’est un nombre impair.
 3. Ecrire une fonction INCREMENTE qui incrémente de 1,
la représentation binaire du nombre contenu dans la liste.
Procédure Incrémente(E/S L: ListeBD)
Var p : ptr Elément;
Debut
PL.queue; // commencer par la droite
Commencer à ajouter un 1
Tant que (p<> nil et cont(p.info) =1) à partir de la droite
faire Tant que la valeur est un
Cont(p.info)0 ; pcont(p.prd); 1, il faut l’inverser en 0
fait; Dès qu’on trouve le 1er
si (p = nil) alors// tous les bits étaient à 1 zéro, on l’inverse en 1
// créer une retenue sortante avant la tête Si tous les bits sont à 1, il
p allouer (tailleDe(Element)); cont(p.prd)nil; faut ajouter un 1 à gauche
Cont(p.info)1; cont(p.svt)L.tete; (retenue sortante) (on
cont(L.tete).prdp; L. tetep; ajoute une cellule)
Sinon cont(p.info) = 1 // inverser le zéro en 1
Fsi;
Fin;
4. Ecrire une fonction AFFICHE qui affiche la
décomposition du nombre.

Procédure Affiche (E/ L: ListeBD)

Var
p : ptr Elément;
Debut
pL.tete;
Tant que (p<> nil) faire
Ecrire cont(p.info ); pcont(p.svt);
fait;
Fin;
 Exercice 6
1. RotationG ({3,7,1,4,0})= {7,1,4,0,3}.

Procedure RotationG(E/S/ L :liste) ;

Var T,Q :liste ;
Debut
Si L<>Nil Alors
Si cont(L.Suiv<>Nil) Alors//il y a au moins deux éléments pour faire un décalage
T←L ; //sauvegarder le premier élément
L←cont(L.Suiv) ; //avancer la tête
Q←L ;
Tantque cont(Q.Suiv<>Nil Faire O(n)
Q cont(Q.Suiv)
Fait ; //recherche de la queue
Cont(Q.Suiv)T ; cont(T.Suiv)Nil //insérer le premier élément à la fin
Fsi
Fsi ;
Fin ;
2-
Liste circulaire
Procedure RotationG2(E/S/ tete :liste) ;
Debut
Si tete<>Nil Alors tetecont(tete.Suiv)
Fsi ;
déplacer la tête de la liste vers l’élément suivant
Fin ;
RotationD ({3,7,1,4,0})= {0,3,7,1,4}.(liste
circulaire)
Procedure RotationD(E/S/ tete :liste) ;
Var T :liste ;
Debut
Si tete<>Nil Alors
Ttete ;
Tantque cont (tete.Suiv)<>T Faire tete← cont(tete.Suiv) ;
Fait ;
Fsi ;
Fin ;
O(n)
4- Comment peut-on réduire sa complexité à O(1).
Liste circulaire doublement chainée :
Procedure RotationD2(E/S/ tete :liste) ;
Debut
Si tete<>Nil Alors tetecont(tete.Pred)
Fsi ;
Fin ;
Exercice 7
1- Affiche les éléments de L.
Procedure Affiche(E/ L :liste) ;
Debut
Si L<>Nil Alors Ecrire (cont(L.val)) ; Affiche(L.Suiv)
Fsi ;
Fin ;

2- Affiche les éléments de L dans l'ordre inverse.

Procedure AfficheInv(E/ L :liste) ;
Debut
Si L<>Nil
Alors AfficheInv(cont(L.Suiv)) ; Ecrire(cont(L.val))
Fsi ;
Fin ; L’affichage se fait au retour
3- Vérifie l’existence d’une valeur X donnée dans L et
retourne son adresse.
Fonction Adresseval(L :liste ; X :entier) :liste ;
Debut
Si (L<>Nil Et cont(L.Val)<>X)
Alors retourner Adresseval (cont(L.Suiv),X)
Sinon retourner L
Fsi;
Fin ;
4- Supprime tous les éléments de la liste L.
Procedure Supprime(E/S/ L :liste) ;
Var T :liste ;
Debut
Si L<>Nil Alors T= cont(L.Suiv) ;
Liberer(L); L←Nil ;
Supprime(T) Ou bien sans variable intermédiaire
Fsi ; On appelle la procédure supprime (L.suiv)
Ensuite on ajoute liberer((L) suivie de Lnil
Fin ;