Pour i0 à n-1faire Ecrire("T[",i

1/8

Correction de la série des travaux dirigés 4

Exercice 1

Ecrire un algorithme Remplir permettant de remplir un tableau T formé de n entiers.

Corrigé :

Algorithme Remplir ;

Constante Max 50: Entier ; Variable Tableau T[Max] : Entier ;

i, n : Entier ; Début

Ecrire("Entrez le nombre d’éléments <50" ) ; Lire(n) ; Pour i0 à n-1faire

Ecrire("T[",i,"]=") ; Lire(T[i]) ;

Fin Pour Fin

Exercice 2

Ecrire un algorithme Afficher permettant d'afficher les éléments d'un tableau T de n entiers.

Corrigé :

Algorithme Afficher ;

Constante Max 100 : Entier ; Variable Tableau T[Max] : Entier

i, n : Entier ; Début

//on suppose que T contienne n éléments < 100 Pour i0 à n-1faire

Ecrire(T[i], " , ") ; //pour séparer les éléments et l’affichage sera: 23 , 100 , 200 , 12 Fin Pour

Fin

2/8 Exercice 3

Ecrire un algorithme MinMax permettant de chercher le minimum et le maximum dans un tableau T de n entiers.

Corrigé :

Algorithme MinMax ;

Constante Max 100 : Entier ; Variable Tableau T[Max] : Entier

i, vmin, vmax, n : Entier ; Début

//on suppose que le tableau est déjà rempli et il est de taille n.

vminT[0] ; vmaxT[0] ; Pour i1 à n-1faire

Si ( vmin> T[i] ) Alors vmin T[i] ; Fin Si

Si ( vmax< T[i] ) Alors vmaxT[i] ; Fin Si

Fin Pour

Ecrire(" Le min du tableau est = ", vmin) ; Ecrire(" Le max du tableau est = ", vmax) ; Fin

Exercice 4

Ecrire un algorithme Recherche_seq qui permet de chercher un entier x dans un tableau T de n entiers

Corrigé :

Principe de la recherche séquentielle :

Comparer x aux différents éléments du tableauT jusqu'à trouver x ou atteindre la fin du tableau.

//Version avec Répéter… Tantque Algorithme Recherche_seq ; Constante Max 100 : Entier ; Variable Tableau T[Max] : Entier

i, n, x: Entier ; trouve : boolean ; Début

//On suppose que le tableau T contient déjà n éléments

3/8 Ecrire(" Entrer l’élément à chercher dans T : ") ; lire(x) ;

i -1; trouvefaux;

Repeter ii+1;

TantQue (T[i] !=x) et (i < n-1) ; //

Si(T[i]==x) Alors trouveVrai ; Fin Si

Si(trouve) Ecrire(" L’élément ", x, " se trouve dans le tableau T ") ; Sinon Ecrire(" L’élément ", x, " ne figure pas dans le tableau T ") ; FinSi

Fin

//Version avec Tant que… Faire Début

i 0 ;

Tant que (T[i] != x) et (i <n-1) Faire i  i+1 ;

Fin Tant que

//interpréter la boucle

Si(T[i]==x) alors trouveVrai ; Sinon trouveFaux ;

FinSi

Si(trouve) alors Ecrire(" L’élément ", x, " se trouve dans le tableau T ") ; Sinon Ecrire(" L’élément ", x, " ne figure pas dans le tableau T ") ; Fin

Exercice 5

Etant donné un tableau trié T de n entiers, écrire un algorithme Recherche_Dicho qui permet de chercher un entier x dans un tableau T.

Corrigé :

Principe de la recherche dichotomique :

Le but de la recherche dichotomique est de diviser l'intervalle de recherche par 2 à chaque itération (étape). Pour cela, on procède de la façon suivante :

Soient premier et dernier les extrémités gauche et droite de l'intervalle dans lequel on cherche la valeur x, on calcule m, l'indice de l'élément médian :

m(premier + dernier) div 2 ; Il y a trois cas possibles :

x < T[m] : l'élément x, s'il existe, se trouve dans l'intervalle [premier..m-1].

x > T[m] : l'élément x, s'il existe, se trouve dans l'intervalle [m+1...dernier].

x == T[m] : l'élément de valeur x est trouvé, la recherche est terminée.

4/8 La recherche dichotomique consiste à itérer ce processus jusqu'à ce que l'on trouve x ou que l'intervalle de recherche soit vide.

Algorithme Recherche_dich ; Constante Max 100 : Entier ; Variable Tableau T[Max] : Entier

n, x : Entier ; premier, m, dernier : Entier ;

trouve : Booleen ; Début

premier0 ; derniern-1 ; trouveFaux ;

Répéter

m (premier + dernier) div 2 ; Si ( x< T[m] ) Alors dernier m – 1 ;

Sinon Si ( x> T[m] ) Alors premier m + 1 ; Sinon trouve Vrai ;

Finsi FinSi

TantQue(non trouve) et(premier<=dernier) ;

Si(trouve) Ecrire(" L’élément ", x, " se trouve dans le tableau T ") ; Sinon Ecrire (" L’élément ", x, " ne figure pas dans le tableau T ") ; FinSi

Fin

Exercice 6

Ecrire un algorithme qui permet de fusionner deux tableaux tries TA et TB contenant respectivement n et m éléments. Le résultat est un tableau trie TC avec (n+m) éléments.

Exemple:

TA 1 20 41 TA 30 100 120 TB 19 20 23 27 54 91 TB 19 23 27 54 91

TC 1 19 20 20 23 27 41 54 91 TC 19 23 27 30 54 91 100 120 Corrigé :

TA : de taille n et d’indice i TB : de taille m et d’indice j TC : de taille n+m et d’indice k On compare TA[i] avec TB[j] ? i0 ; j0 ; k0 ;

5/8 Tantque ( i<n) et (j<m) faire

Si TA[i]<=TB[j] alors TC[k] TA[i] et avancer i i + 1 ; kk +1 ;fsi Si TB[j]<=TA[i] alors TC[k] TB[j] et avancer jj + 1 ; kk +1 ;fsi finTq

Qui est ce qui reste ? des éléments soit ds TA ou ds TB

Si il reste encore des éléments ds TA, il faut les copier dans TC Tant que (i <n) Faire TC[k] TA[i] ; i i + 1 ; kk +1 ; FinTant que

Si il reste encore des éléments ds TB, il faut les copier dans TC Tant que (j <m) Faire TC[k] TB[j] ; jj + 1 ; kk +1 ; FinTant que

Algorithme Fusion ;

Constante Max 100 : Entier ;

Variable Tableau TA[Max],TB[Max], TC[2*Max] : Entier ; i, j, n, m, k : Entier;

Début

//on suppose que TA contienne n éléments triés et i son indice //on suppose que TB contienne m éléments triés et j son indice //TC va contenir donc n+m éléments et k son indice

k0 ; i0 ; j0 ;

Tant que (i < n) et (j < m) faire

//On a l'élément de TA et plus petit que TB alors on ajoute TA[i] dans TC Si (TA[i] <=TB[j]) alors TC[k]A[i];

i i + 1;

kk +1;

FinSi

//On a l'élément de TA et plus grand que celui de TB alors on ajoute TB[j] dans TC Si (TB[j] <= TA[i]) alors TC[k]TB[j] ;

jj + 1 ; kk +1 ; FinSi

FinTant que

//Si on a encore des éléments dans TA alors on les rajoute successivement dans TC Tant que (i <=n) Faire

TC[k] TA[i] ; i i + 1 ; kk +1 ; FinTant que

//Si on a encore des éléments dans TB alors on les rajoute successivement dans TC Tant que (j <=m) Faire

TC[k] TB[j] ; jj + 1 ;

kk +1 ;

6/8 FinTant que

Fin

Exercice 7

1. Ecrire un algorithme permettant de remplir une matrice;

2. Ecrire un algorithme permettant d'afficher une matrice;

3. Ecrire un algorithme qui renvoie la somme de deux matrices M1 et M2;

4. Ecrire un algorithme qui renvoie le produit de deux matrices M1 et M2;

Corrigé :

//Remplissage d'une matrice Algorithme Remplir ;

Constantes MaxM100 :Entier ; MaxN 100 : Entier ;

Variable Tableau Mat[MaxM][MaxN] : Entier ; i, j, n, m : Entier ;

Début

Pour i 0 à n-1faire

Pour j0 à m-1faire

Ecrire("Entrer un entier : ") ;Lire(Mat[i][j]) ; FinPour

FinPour Fin

//Affichage d'une matrice AlgorithmeAfficher ;

Constantes MaxM100 :Entier ; MaxN 100 : Entier ;

Variable Tableau Mat[MaxM][MaxN] : Entier ; i, j, n, m : Entier ;

Début

Pour i 0 à n-1faire

Pour j0 à m-1faire

Ecrire(Mat[i][j], " ") ; FinPour

FinPour Fin

// Somme de deux matrices Principe:

Soient M1 et M2 deux matrices avec n lignes et m colonnes.

M3 = M1 + M2

7/8 Algorithme SomMat ;

Constantes MaxM100 :Entier ; MaxN 100 : Entier ;

Variable Tableau M1[MaxM][MaxN], M2[MaxM][MaxN] : Entier ; Tableau M3[MaxM][MaxN] : Entier ;

i, j, n, m : Entier ; Début

//on suppose que M1 et M2 contiennent des éléments Pour i 0 à n-1Faire

Pour j 0 à m-1Faire

M3[i][j] M1[i][j] + M2[i][j];

FinPour FinPour

Fin

Algorithme ProdMat ;

Constantes MaxM100 :Entier ; MaxN 100 : Entier ;

Variable Tableau M1[MaxM][MaxN], M2[MaxM][MaxN] : Entier ; Tableau M3[MaxM][MaxN] : Entier ;

i, j, k, n, m : Entier;

Début

//on suppose que M1 et M2 contiennent des éléments Pour i0 à n-1 Faire

Pour j0 à m-1 Faire M3[i][j] 0 ;

Pour k 0 à m-1 Faire

M3[i][j] M3[i][j] + M1[i][k] * M2[k][j];

Fin Pour Fin Pour

Fin Pour Fin

Exercice 8

Écrire le pseudo-code d’un algorithme qui demande à l’utilisateur de saisir une série de 30 chiffres (0 à 9), et affiche celui qui a été tapé le plus de fois.

Exemple : une série de 30 chiffres de 0 à 9.

tab1 : 7 3 2 1 0 3 2 7 2 7 8 6 5 3 7 5 3 0 1 2 7 4 5 6 7 8 9 9 9 9 Le chiffre 7 est répété 6 fois

8/8 Corrigé :

Soit tabRep un tableau de répétition de taille 10 de sorte que :

tabRep[0] : va contenir le nombre de fois 0 à été répété dans tab1 : 2 ds l’exemple tabRep[1] : va contenir le nombre de fois 1 à été répété dans tab1 :2 ds l’exemple

…

tabRep[9] : va contenir le nombre de fois 9 a été répété dans tab1 :4 ds l’exemple On remarque que tab1[i] pour i 0 à 29 est un chiffre de 0 à 9

ce qui permet de penser à mettre à jour le compteur du chiffre tab1[i] dans tabRep

Algorithme occurrence ;

variables tableau tab1[30] : entiers ; //pour contenir les 30 chiffres

tableau tabRep[10] : entiers ; //contenir le nombre de fois chaque chiffre de 0 à 9 //a été répété

i, j, valMax, nombreMax : entier ; Début

i0 ;

TantQue(i<30) faire

Ecrire("veuillez saisir un chiffre (0 à 9). ") Lire( tab1[i]) ;

tabRep[tab1[i]]tabRep[tab1[i]]+1 ; ii+1 ;

FinTantQue

//on cherche la plus grande valeur dans tabRep j0 ;

valMax0 ;

TantQue(j<=9) faire

Si (valMax<tabRep[j]) alors valMaxtabRep[j] ; nombreMax j ;

finSi jj + 1 ; FinTantQue

Ecrire(" le nombre ", nombreMax, " a été tapé ", valMax, " fois ",) Fin