Exercice SR É Vison Ex Amen

ESI CPI1 - Cours dAlgorithmique Exercices avec corrigs
A LIRE ABSOLUMENT
Pour maitriser les concepts de base il ne sagit pas de faire beaucoup dexercices car sils se ressemblent un seul
suffit. Mais il faut cibler quelques exercices bien choisis et surtout essayer de les rsoudre tout seul. Pour cela, il faut bien
entendu connatre son cours et cest seulement aprs quil faut attaquer les exercices. Cela est commun toutes les
matires.
Dans le cas de lalgorithmique, le but essentiel est de matriser le processus de dveloppement mais aussi de
sinterroger chaque tape du raisonnement de la cohrence de votre solution. Une fois que vous maitriserez ce
processus, vous pourrez affronter nimporte quel problme. Donc lorsque vous faites un exercice, ne le faites pas de faon
machinale mais vrifiez chaque tape que vous respectez la dmarche tudie et posez-vous les bonnes questions au bon
moment. Une fois que la dmarche est bien intriorise, vous commencerez lappliquer de faon naturelle. Arriv ce
niveau vous verrez par vous mmes les progrs que vous aurez accomplis et la facilit avec laquelle vous aborderez les
problmes les plus difficiles.
Dans les problmes que vous aurez rsoudre, les structures de donnes ncessaires votre solution peuvent
parfois vous tre imposes mais dans dautres cas cest vous de les proposer, lessentiel nest pas de trouver la mme
solution que votre enseignant ou lauteur dun livre, mais den proposer une qui soit logique, qui correspond au problme
rsoudre mais surtout den tenir compte tout au long de votre conception.
Les trois exercices qui vous sont proposs sont tous diffrents, non pas par rapport au sujet quils traitent mais par
rapport aux concepts quils mettent en uvre.
Dans le premier, une fois que la structure de donnes est arrte, la solution en elle mme nest pas complique si
on connat son cours. Il sagit de bien connatre comment on dclare un enregistrement et comment on manipule ses
diffrents champs ? Et bien sur de connatre les notions de base sur les chanes de caractres et les tableaux.
Dans le deuxime exercice lanalyse est pratiquement donne dans le sujet mais elle ncessite une connaissance
correcte des tableaux 2 dimensions, un bon dcoupage, un bon jeu dessai et une vigilance dans le droulement.
Dans le troisime exercice, outre la connaissance correcte des tableaux 2 dimensions cest la comprhension du
problme qui va ncessiter de lattention, car une fois que lon a compris le problme son analyse nest en principe pas
trs difficile.
Dans le quatrime exercice, la comprhension du problme nest pas dure, si on a dj fait le troisime exercice
mais cest lanalyse qui va exiger de la concentration et de la rflexion. Une fois cet cueil surmont il faut savoir
comment exprimer son ide et faire trs attention lors du droulement.
Ne faites pas des algorithmes comme si cest une corve mais prenez du plaisir affronter les problmes et
surtout les surmonter, les dcouper, concevoir la solution mais aussi la raliser.
Ne consulter pas les solutions des problmes au dpart, cest une trs mauvaise faon dapprendre.
Commencez, selon les exercices proposs, par imaginer une structure de donnes si elle ne vous est pas impose,
puis procder au dcoupage et sa justification. A ce moment, et si vous le souhaitez ou alors si vous tes
compltement bloqu confrontez votre proposition la solution. Attention ! Il ne sagit pas de trouver exactement la
mme chose mais dtre cohrent. Une structure de donne diffrente peut aboutir un dcoupage diffrent. Un problme
peut avoir plusieurs solutions. On peut dcouper une mme ide de faons diffrentes. Le plus important est que votre
dcoupage soit logique. Vrifiez les interfaces de vos modules et soignez particulirement leurs rles, qui doivent tre
prcis, clairs et concis.
Une fois ces deux tapes franchies, le reste ne pose pas de problme particuliers. Construisez chaque module
SEPAREMENT (analyse, algorithme, jeu dessai bien choisi et droulement).
Ouf ! La conception est termine. Attaquez la ralisation. La aussi pas de secret, il faut connatre le minimum
pour programmer, avoir TOUJOURS porte de main la documentation fournie et surtout la consulter chaque erreur.
Lorsque vous saurez utiliser correctement cette documentation et retrouver tout seul vos erreurs et les corriger vous
venez de faire un grand pas vers lAUTONOMIE. Cest le but ultime dune bonne cole.
Voila ! Ce que je vous propose est une trs bonne prparation votre examen. Attention ! le sujet sera totalement
diffrent mais la dmarche sera la mme.
Nous sommes arrivs au terme du cours, faites votre propre diagnostic, travaillez surtout les aspects dans lesquels
vous manquez dassurance.
Abordez ces exercices comme des jeux, sans stress inutile !
La veille de votre examen, faites un peu de sport ou simplement quelques kilomtres de marche rapide, dormez
de bonne heure. Le jour de lpreuve, prenez un bon petit djeuner et un jus dorange (citron, pamplemousse) et
concentrez vous sur votre preuve, et seulement votre preuve.
Bonne chance tous !
1 / 21
Merci denvoyer vos remarques , critiques et observations : B_CHERGOU@ESI.dz
EXERCICE 1 :
Nous souhaitons construire un objet qui a les caractristiques suivantes :
Il contient une phrase que lon saisira et en mme temps
1. un tableau dont chaque lment contiendra un mot constituant cette phrase
2. le nombre de mots
3. et un autre tableau qui contiendra la frquence dapparitions de chaque lettre de lalphabet et ses positions dans la
phrase donne
Une fois le traitement termin nous afficherons cet objet de la manire suivante :
Phrase donne : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

Elle contient xx mots et qui sont :
mot1 | mot2 | mot3 |..
A apparat nn fois et dans les positions : n, n, n, n, n, .,n
B apparat nn fois et dans les positions : n, n, n, n, n, .,n
C apparat nn fois et dans les positions : n, n, n, n, n, .,n
.
.
Z apparat nn fois et dans les positions : n, n, n, n, n, .,n
Nota : les mots de la phrase sont spars par un ou plusieurs blancs et il ny a pas de caractres spciaux
SOLUTION :
La premire tape consiste dcrire lobjet. Comme il est compos dautres objets de types diffrents, sa structure sera de
type enregistrement.
Plusieurs solutions sont possibles, lessentiel est de proposer une structure cohrente qui rpond notre problme mais
surtout de la respecter tout au long de notre solution.
On prendra donc celle qui dcoule naturellement de notre nonc.
Notre enregistrement contiendra :
1. la phrase donne
2. un tableau une dimension qui contiendra les diffrents mots
3. le nombre de mots
4. un tableau deux dimensions, de 26 lignes, dont chacune correspondra une lettre de lalphabet ( de A Z). La
1re colonne, de chaque ligne, contiendra la frquence (nombre) dapparitions de la lettre, et les autres colonnes
contiendront les positions ou apparat la lettre.
Nota : pour ce deuxime tableau plusieurs solutions sont possibles
TYPE tab1= tableau [1..100] dentiers

tab2 = tableau [1..26,1..100] dentiers
Tab3 = tableau [1..100] de chane [25]
E= ENREGISTREMENT
ph : Chane
Tmot : tab3
NbMots: Entier
T2 : tab2
FIN
Procdons maintenant notre dcoupage. Pour cela il suffit de complter lenregistrement partir dune phrase donne et
ensuite de lafficher selon une forme prcise. On aura ainsi besoin :
dun module (DECMOTS) qui va nous donner les diffrents mots qui composent notre phrase et leur nombre
dun module (FREQPOS) qui fournit la frquence dapparitions dune lettre donne dans une chaine de mme que ses
diffrentes positions
2 / 21
On aura aussi besoin des fonctions standards ; Length(c) et Chr (x)

Laffichage tant trs particulier nous le traiterons dans lalgorithme principal.
CONSTRUCTION DU MODULE DECMOTS

Analyse : on extrait les mots de C un un, on les met dans un tableau et on compte leur nombre
Nbm = 0 nombre de mots
Mot = '' est une chaine qui va contenir un seul mot (vide au dpart)
On varie I = 1,2,3,,length(c) pour lire les caractres de C un un
o Si c[i] = blanc on rencontre un blanc
9 si mot nest pas une chaine vide il y donc un mot dans Mot
Nbm = Nbm +1 on incrmente le nombre de mots
t[Nbm] = mot on met le mot dans une case de T
mot= '' on remet une chaine vide dans Mot
9 si c[i] est diffrent de blanc
mot = mot + c[i]on concatne le caractre avec Mot, pour reconstituer le mot lu
si mot nest pas une chaine vide lorsque lon sort de la boucle on vrifie sil ne reste pas un mot dans Mot, si
cest le cas
o Nbm = Nbm +1 on incrmente le nombre de mots
o t[Nbm] = mot on met le mot dans une case de T
Algorithme
Procdure DecMots (c: Chane ; VAR T:tab3; VAR Nbm : Entier)

variables i : entier
mot : chane [25]
DEBUT
Nbm 0
Mot ''
Pour i allant de 1 length(c) Faire
Si c[i] = ' ' Alors
SI mot <> ' ' ALORS
DSI
Nbm Nbm +1
t[Nbm] mot
mot ''
FSI
Sinon mot mot + c[i]
Si mot <> ' ' Alors
DSI
Nbm Nbm +1
t[Nbm] mot
FSI
FIN
3 / 21
CONSTRUCTION DU MODULE FREQPOS
Analyse : on parcourt la chaine on compte, ds que lon rencontre le caractre L, on incrmente un compteur et on met sa
position dans POS
freq = 0 freq va contenir la frquence dapparitions du caractre L dans la chane C

k = 1 k est lindice de la case du tableau Pos dans laquelle sera range une position de L
On varie I = 1,2,3,,length(c) pour lire les caractres de C un un
o Si upcase(c[i]) = upcase(L) on met tout en majuscules afin de prendre en compte le caractre mme sil
est en minuscule , alors on fait :
9 freq = freq +1 on incrmente la frquence
9 pos[k] = I on met la position du caractre dans le tableau
9 k = k+1 on incrmente lindice du tableau Pos
Algorithme
Procedure Freqpos (c: Chane ;L: caractre; var freq: Entier ;var Pos : tab1);
Variables i, k : Entier
DEBUTfreq:=0
k:=1
Pour i allant de 1 length(c) Faire
Si upcase(c[i]) = upcase(L) Alors
DSI
freq freq +1
pos[k] i
k k+1
FSI
FIN
CONSTRUCTION DE LALGORITHME PRINCIPAL

on lit la phrase
on extrait la table (Tmot) des mots et leur nombre (Nbmots) et on les met dans les champs de TabP
DecMots(tabP.ph , tabp.Tmot , tabp.Nbmots)
on remplit le tableau qui contient les frquences et les positions de chaque lettre, pour cela
o on varie i = 1, 2, 3, ,26 les 26 lettres de lalphabet et pour chaque lettre
lettre = CHR(64+i) la lettre A est la position 65 dans la liste des caractres ASCII
FREQPOS (TAbP.ph , lettre , f , p) on value la frquence de chaque lettre et ses positions
tabP.T2[i,1] = f on met la frquence dans la 1re colonne (voir struct. Enregistrement)
on varie j = 1, 2, , F puis on met les diffrentes positions dans la table T2(cf struct. enr)
TabP.T2[i,j+1] = p[j]
Notre enregistrement est rempli, nous allons lafficher selon le format donn dans lnonc
Ecrire ( 'Phrase donnee : ', tabp.ph)

Ecrire ('Elle contient ', tabP.NbMots, ' mots et qui sont : ')
On varie i = 1, 2 , , tabP.NbMots et chaque fois
o On crit (tabP.Tmot[i] , ' | ')
On varie I = 1, 2, ,26 et chaque fois on va crire les frquences et les positions de chaque lettre
Si tabP.T2[i,1] <> 0 on ignore les lettres qui apparaissent 0 fois
9 Ecrire (chr(64+i), ' apparait ', tabP.T2[i,1],' fois et dans les positions : ')
9 On varie j = 1, 2, ,tabP.T2[i,1] et chaque fois
o Ecrire ( TabP.T2[i,j+1],' ,')
Nota : vous avez constat lintrt dutiliser la fonction CHR(x) elle nous permet dviter des Si en cascade.
Si i = 1 alors lettre A
Sinon si i = 2 alors lettre B
Sinon si i = 3 alors lettre C (..cela 26 fois)
4 / 21
ALGORITHME exo_sup01
type tab1= Tableau [1..100] dentiers
tab2 = Tableau [1..26,1..100] dentiers
Tab3 = Tableau [1..100] de chane[25]
E= ENREGISTREMENT
ph : chane
Tmot : tab3
NbMot s: entiers
T2 : tab2
FIN
variables tabP : E
f, i, j: entiers
p : tab1
p2 : tab2
TfrPos : tab2
lettre: caractre
Procdures DECMOTS , FREQPOS
DEBUT
Ecrire ('Donner votre phrase : ')
Lire (TabP.ph)
DecMots(tabP.ph,tabp.Tmot,tabp.Nbmots)
Pour I allant de 1 26 Faire
Dpour
Lettre CHR(64+i)
FREQPOS(TAbP.ph,lettre,f,p)
tabP.T2[i,1] f
for j:=1 to F do
TabP.T2[i,j+1] p[j]
Fpour
Saut de ligne
Ecrire ('Phrase donnee : ', tabp.ph)
Saut de ligne
Ecrire ('Elle contient ' , tabP.NbMots, ' mots et qui sont : ')
Pour i allant de 1 tabP.NbMots Faire
Ecrire (tabP.Tmot[i] , ' | ')
Saut de ligne
Pour i allant de 1 26 Faire
Dpour
Si tabP.T2[i,1] <> 0 Alors
Dsi
Ecrire (chr(64+i), ' apparait ' , tabP.T2[i,1], ' fois et dans les positions : ')
Pour j allant de 1 tabP.T2[i,1] Faire
Ecrire ( TabP.T2[I , j+1] , ' ,')
Saut de ligne
Fsi
Fpour
FIN
5 / 21
LES PROGRAMMES
MODULE FREQPOS
Procedure Freqpos(c:string;L:char;var freq:integer;var Pos:tab1);
// Donne un tableau(POS) une dimension dont le 1er element contient la frequence

// d'apparitions de la lettre L dans la chaine C, et les autres elements contiennent
//les positions ou se trouve la lettre L
//type tab1= array[1..100] of Longint;
var i,k :longint;

BEGIN
freq:=0;
k:=1;
for i :=1 to length(c) do
if upcase(c[i])= upcase(L) then
BEGIN
freq := freq +1;
pos[k]:=i;
k:=k+1;
END;
END;
MODULE FDECMOTS
Procedure DecMots(c:string;VAR T:tab3;VAR Nbm:integer);
//donne un tableau qui contient les mots qui compose la chaine C et leur nombre (NbM)
// type Tab3 = array[1..100] of string[25];
var i :integer;
mot :string[25];
BEGIN
Nbm:=0;
mot:='';
for i := 1 to length(c) do
if c[i] =' ' then
BEGIN
if mot <> ' ' then
BEGIN
Nbm := Nbm +1;
t[Nbm] := mot;
mot:='';
END;
END
else mot :=mot + c[i];
if mot <> ' ' then
BEGIN
Nbm := Nbm +1;
t[Nbm] := mot;
END;
END;
6 / 21
PROGRAMME PRINCIPAL
program exo_sup01;
// exercice sur les objets de types enregistrement, tableaux et chaine de caracteres
uses Crt;
type tab1= array[1..100] of integer;
tab2 = array[1..26,1..100] of integer;
Tab3 = array[1..100] of string[25];
E = record
ph : string;
Tmot: tab3;
NbMots:integer;
T2:tab2;
END;
var tabP :E;
f,i,j:integer;
p:tab1;
p2 :tab2;
TfrPos:tab2;
lettre:char;
{$i c:\algo\modules\DECMOTS.pro}
{$i c:\algo\modules\FREQPOS.pro}
BEGIN
clrscr;
Write('Donner votre phrase : ');
readln(TabP.ph);
DecMots(tabP.ph,tabp.Tmot,tabp.Nbmots); // on extrait les mots et leur nombre
// on remplit le tableau qui contient les frequences et les positions de chaque lettre
for i:=1 to 26 do
BEGIN
lettre:=CHR(64+i); // pour avoir les 26 lettres de l'alphabet
FREQPOS(TAbP.ph,lettre,f,p); //on evalue la frequence de chaque
//lettre et ses positions
tabP.T2[i,1] := f; //on complete l'enregistrement
for j:=1 to F do
TabP.T2[i,j+1]:=p[j];
END;
Writeln;
// affichage selon le format donne
writeln('Phrase donnee : ',tabp.ph);
writeln;
writeln('Elle contient ',tabP.NbMots, ' mots et qui sont : ');
for i := 1 to tabP.NbMots do
write(tabP.Tmot[i], ' | ');
writeln;
writeln;
for i := 1 to 26 do
BEGIN
if tabP.T2[i,1] <> 0 then
BEGIN
write(chr(64+i), ' apparait ', tabP.T2[i,1],' fois et dans les positions
: ');
for j := 1 to tabP.T2[i,1] do
write ( TabP.T2[i,j+1],' ,');
writeln;
END;
END;
readln;
END.
7 / 21
RESULTATS
Essayer maintenant de faire le travail inverse. On donne le tableau qui contient la frquence des
caractres et leurs positions et on veut reconstruire la phrase de dpart que mme que son
dcoupage en mots et leur nombre.
Sauriez-vous le faire ?
8 / 21
EXERCICE 2 :
Le dterminant dune matrice est une valeur scalaire. Si vous prenez une matrice carre de 2 sur 2,
A 1 2
1 x11 x12
2 X21 X22
Le dterminant de la matrice carre A(2,2) est DetA = (x11.x22 ) (x12.x21 )

Par exemple si on prend la matrice :
A 1 2
1 1 2
2 3 4
Le dterminant est gal (1 * 4 ) ( 2 * 3 =) = -2
Dans le cas gnral la formule du dterminant est :
A * Det (cofacteur ( A))

i+ j
Det ( A) = ( 1) + ij
avec i = 1
ij
j =1
Un cofacteur dindices i,j est dfini comme lensemble des lments de la matrice dont la ligne i et la colonne j sont
enleves. Par exemple, dans la matrice carre A(3,3)
A 1 2 3
1 1 2 3
2 4 5 6
3 7 8 0
Cofacteur21(A) =
1 2
1 1 3
2 8 0
Exemple : si nous voulons calculer le dterminant de la matrice A dordre 3, ci-dessus :
5 6 4 6 4 5
DetA = +1* Det ( ) 2 * Det ( ) + 3 * Det ( )
8 0 7 0 7 8
Soit DetA = 1 * (0 48) 2 * (0 42) + 3 * (32 35) = - 48 + 84 9 = 27
Donc le dterminant de la matrice A donne est DetA = 27
Travail demand : Calcul du dterminant dune matrice carre dordre 3
9 / 21
Dcoupage modulaire :
On aura besoin des module suivants

Calcul du dterminant dune matrice dordre 2
Calcul du cofacteur(i,j) dune matrice T(m,n)
Calcul du dterminant dune matrice dordre 3
Et bien sur de la procdure de lecture dun tableau et de la fonction de calcul de la puissance (en principe faits en
TDs)
Construction du module DET2

Analyse : comme il sagit dune matrice dordre 2, il suffit dappliquer tout simplement la formule donne, savoir :
DetA = x11.x22 - x12.x21
Algorithme :
fonction Det2(a : tab2) : entier
DEBUT
det2 a[1,1] * a[2,2] - a[1,2] * a[2,1]
FIN
Construction du module COFACT
Analyse
Il faut ignorer les lments de T se trouvant sur la ligne i et sur la colonne j, pour cela :
On parcourt toutes les lignes et pour chaque ligne m

o On parcourt toutes les colonnes n et pour chaque lment de T
Si m diffrent de i et n diffrent de j, on met llment T[m,n] dans le COF[lco,cco]
10 / 21
Attention : Les indices Lco et Cco progressent videmment de faon diffrente que m et n . leur bornes sont L-1 et C-1
(puisque COF aura une ligne et une colonne en moins que T).
Algorithme
Procedure cofact (T : tab2 ; l, c, i, j : entier; var cof : tab2 ; var lco, cco : entier)
Variables m, n, l2, c2:entier
DEBUT
Lco 1
Cco 1
Pour m Allant de 1 l Faire
Pour n Allant de 1 c Faire
Si (m<>i) ET (n<>j) Alors
Dsi
cof[lco,cco] T[m,n];
l2 lco
c2 cco
cco cco+1
Si cco > c-1 Alors
Dsi
Cco 1
Lco lco+1
Fsi
Fsi
Lco l2
Cco c2
FIN
Construction du module DET3
Analyse : il suffit dappliquer la formule donne

On fait varier j de 1 3 (puisquil sagit dune matrice de 3 x 3)
o On calcule le cofacteur11 de T soit : Cofact(t, 3, 3, 1, 1, cf, l, c)
o On cumule dans Res les diffrentes valeurs obtenues soit :
Res res + puiss(-1,j + 1) * t[1,j] * det2(cf)
Nota : comme i est gal 1, on le remplace par sa valeur
Algorithme
fonction det3 (t : tab2 ) : Entier

variables j, l, c, res : Entier
Cf : tab1
Fonction puiss.fon
DEBUT
Res 0
Pour j Allant de 1 3 Faire
Dpour
Cofact(t, 3, 3, 1, 1, cf, l, c)
Res res + puiss(-1,j + 1) * t[1,j] * det2(cf)
Fpour
det3 res
FIN
11 / 21
Construction de lalgorithme principal
ALGORITHME exosup01
type Tab2=Tableau[1..100,1..100] dentier
variables A: tab
x, y: Entier
Procdure lect2d
Fonction DET3
DEBUT
lect2d(A,x,y);
writeln(DET3(A))
FIN.
PROGRAMMES
function Det2(a:tab2):integer;
(* --------- donne le determinant d'une matrice carree d'ordre 2 -------- *)
BEGIN
det2:=a[1,1]*a[2,2]-a[1,2]*a[2,1];
END;
=============================================================================
Procedure cofact(T:tab2;l,c,i,j:integer; var cof:tab2;var lco,cco :integer);
(* -- donne le cofacteur d'indices i,j (cof(lco,cco)) de la matrice T(l,c)-- *)
var m,n,l2,c2:integer;
Begin
lco:=1;
cco:=1;
for m:=1 to l do
for n:=1 to c do
if (m<>i) and (n<>j) then
Begin
cof[lco,cco]:= T[m,n];
l2:=lco;
c2:=cco;
cco:=cco+1;
if cco > c-1 then
Begin
cco:=1;
lco:=lco+1;
End;
End;
lco:=l2;
cco:=c2;
End;
============================================================================
function det3(var t:tab2):longint;
(* ---------- donne le determinant d'une matrice carree d'ordre 3 ------- *)
var j,l,c,res: integer;
Cf:tab2;
{$i E:\Algo\modules\puiss.fon}
{$i E:\Algo\modules\cofact.pro}
{$i E:\Algo\modules\det2.fon}
12 / 21
Begin
res:=0;
for j:= 1 to 3 do
Begin
Cofact(t,3,3,1,j,cf,l,c);
res:= res + puiss(-1,j+1)*t[1,j]*det2(cf);
End;
det3:=res;
End;
==============================================================================
program exosup01;
uses wincrt;
type Tab2=array[1..20,1..20] of integer;
var A,C: tab2;
x,y,:integer;
{$i E:\Algo\modules\lect2d.pro}
{$i E:\Algo\modules\det3.fon}
BEGIN
lect2d(a,x,y);
writeln(' Le determinant de la matrice d''ordre 3 est : ',Det3(a));
END.
13 / 21
EXERCICE 3
Qu'est ce qu'une grille autorfrente ?
Une grille autorfrente est une matrice de cinq (5) lignes et cinq (5) colonnes. Elle est compose de deux (2) parties :
1. une partie A (grise) compose des 2 colonnes de gauche
2. une partie B des 3 colonnes de droite
A
B
4 2 1 2 2
5 1 2 4 5
1 1 5 6 7
2 0 8 0 0
3 6 0 0 0
Dans la premire colonne de la partie A,

le nombre 4 indique le nombre de 1 de la grille
Dans la deuxime colonne de la partie A,

Problme ; comment remplir la partie B dune grille autorfrente dont on vous donne la partie A ?
A
B
4 2 0 0 0
5 1 0 0 0
1 1 0 0 0
2 0 0 0 0
3 6 0 0 0
14 / 21
SOLUTION
Dcoupage Modulaire : nous constatons quune case de la partie A nous donne le nombre dun chiffre donn dans le
tableau, ce chiffre pouvant aussi se trouver dans la partie A. nous allons donc compter le nombre dapparitions de ce
chiffre dans la grille de dpart (ou seule la partie A est donne) grce au module ComptVal. Et partir de l, nous allons
complter ventuellement la partie B. Par exemple si le chiffre 1 doit apparatre 5 fois , mais il existe dj 2 fois dans la
partie A , nous allons mettre trois 1 dans la partie B et ce grce au module CompleteB. A partir de ces deux modules nous
pouvons alors remplir toute la partie B partir de la partie A (module AutorefB). On aura aussi besoin des modules
Lect1d (T,l,c) et ecrit2d(T,l,c) , dj construits pour lire la grille initiale et crire la grille remplie.
Le dcoupage comporte les modules suivants :
PROCEDURE
T : Tab2
Nb : entier CompleteB T : Tab2
Chif : entier
Rle : Complte le Tableau T (5,5) de faon ce que NB cases de T

contiennent la valeur: chiffre et en ne remplissant que les cases contenant
au dpart zro.
Construction de COMPTVAL
Analyse :
On parcourt tout le tableau T et chaque fois que T[i,j]= val on incrmente un compteur (CPT)
fonction COMPTVAL(T:tab2 ; l, c, val : Entier):entier

Variables i, j, cpt : Entier
DEBUT
Cpt 0
Pour i allant de 1 l faire
Pour j allant de 1 c faire
Si t[i,j]=val Alors cpt cpt+1
COMPTVAL cpt
FIN
15 / 21
Construction de COMPLETEB
Analyse :
On remplit Nb cases de T qui contiennent 0 par le chiffre donn
Mais en commenant par la 3ime colonne.
procedure CompleteB (VAR T : tab2 ; nb ,chiffre : Entier)

Variables i,j,k:Entier
DEBUT
I1
J 3
K
rpeter
Si T[i,j] = 0 Alors
DSI
T[i,j] chiffre
K k+1
FSI
J j+1
Si j>5 Alors
DSI
I i+1
j 3
FSI
Jusqu' k=nb
FIN
Construction de AUTOREFA
Analyse :
Chiffre = 1
on fait varier j de 1 2 La partie A na que 2 colonnes
On fait varier i de 1 5 la grille a 5 colonnes
On compte le nombre d'apparitions du chiffre Chiffre dans la grille
nb = COMPTVAL(T,5,5,chiffre)
on complte T de faon ce que T[i,j] Nb cases contiennent chiffre
COMPLETEB(T,T[i,j] nb,chiffre)
on incrmente chiffre
(attention si chiffre > 9 on y met 0,) pour traiter le chiffre 0
procdure AUTOREFA(var T:tab)

Variables i,j,chiffre,nb:Entier
DEBUT
Chiffre 1
Pour j allant de 1 2 faire
Pour i allant de 1 5 faire
DPOUR
Nb COMPTVAL(T, 5, 5, chiffre)
COMPLETEB(T, T[i,j] - nb, chiffre)
Chiffre chiffre+1
Si chiffre > 9 Alors chiffre 0
FPOUR
16 / 21
FIN
PROGRAMMES
================================================================================
function COMPTVAL(T:tab2;l,c,val:integer):integer;
// donne la frequence d'apparitions de la valeur Val dans le tableau T(l,c)
var i,j,cpt:integer;
BEGIN
cpt:=0;
for i:=1 to l do
for j:= 1 to c do
if t[i,j]=val then cpt:= cpt+1;
COMPTVAL := cpt;
END;
procedure COMPLETEB(VAR T:tab2;nb,chiffre:integer);
// Complete le tableau T(5,5) de facon a ce que Nb cases de T contiennent

// la valeur Chiffre et en ne remplissant que les cases contenant zero
var i,j,k:integer;
BEGIN
i:=1;
j:=3;
k:=0;
repeat
begin
if T[i,j] = 0 then
begin
T[i,j]:= chiffre ;
k:=k+1;
end;
j:=j+1;
if j>5 then
begin
i:= i+1;
j:=3;
end;
end;
until k=nb;
END;
procedure AUTOREFB(var T:tab2);
// complete la partie B d'une grille autoreferente
var i,j,chiffre,nb:integer;
{$i E:\Algo\modules\comptVal.fon}
{$i E:\Algo\modules\CompleteB.pro}
BEGIN
chiffre:=1;
for j:=1 to 2 do
for i:= 1 to 5 do
Begin
nb:= COMPTVAL(T,5,5,chiffre);
COMPLETEB(T,T[i,j]-nb,chiffre);
chiffre:=chiffre+1;
if chiffre >9 then chiffre :=0;
end;
END;
===========================================================================
program exosup03;
17 / 21
uses crt;
type tab2=array [1..5,1..5] of integer;
var i:integer;
A : tab2;
{$i E:\Algo\modules\AutorefB.pro}
{$i E:\Algo\modules\lect2d.pro}
{$i E:\Algo\modules\ecrit2d.pro}
BEGIN
clrscr;
lect2d(A,i,i);
AUTOREFB(A);
Writeln ('Remplissage de la partie B d''une grille autoreferente');
ecrit2d(A,5,5);
readln;
END.
RESULTATS
18 / 21
EXERCICE 4
Comment remplir la partie A dune grille autorfrente ?
A
B
0 0 1 2 2
0 0 2 4 5
0 0 5 6 7
0 0 8 0 0
0 0 0 0 0
SOLUTION
La solution est un peu plus complexe que la prcdente et il faut absolument trouver la solution de lexemple
compltement afin de bien observer comment il faut remplir la partie A ?
Dcoupage Modulaire : on aura besoin de compter le nombre dapparitions dun chiffre dans la grille de dpart (ou
seule la partie B est donne) grce au module ComptVal dj construit. Et partir de l, nous allons complter la partie A
(module AutorefA). On aura aussi besoin des modules Lect1d (T,l,c) et ecrit2d(T,l,c) , dj construits pour lire la grille
initiale et crire la grille remplie.
CONSTRUCTION Du MODULE AutorefA
Analyse :
Le petit problme, cest quen remplissant la partie A , nous pouvons y mettre un chiffre que nous avons dj compt. Par
exemple si le chiffre 1 apparat 1 fois dans la grille, on va mettre 1 dans la partie A. Dans ce cas le 1 apparaitra 2 fois
dans la grille, cest ce petit problme qui sera rgl dans le module AutorefA.
Donc, on va remplir la partie A (qui contient au dpart des zros) de faon automatique, mais chaque fois quon la
modifie ,il faudra la remplir nouveau. On sarrtera quand ? eh bien ! Quand elle ne sera plus modifie. Et cest un
aiguillage boolen que lon utilisera pour cela.
Aig = faux (cet aiguillage servira savoir si une case de la partie A de la grille a t modifi)
on rptera ce qui suit tant que aig = faux
on met vrai dans aig ( lorsque l'on ne modifie plus T cela signifie que la partie A de la grille est
correcte)
chiffre =1 (cest le chiffre dont on cherchera le nombre dapparitions)
on fait varier j :1 , 2 (les 2 colonnes de la partie A)
on fait varier i : 1, 2,..,5 et chaque fois les 5 lignes de la partie A)
on compte le nombre d'apparitions de chiffre dans la grille
nb_App = COMPTVAL(T, 5, 5, chiffre)
si t[i,j] <> nb_app (on fait le nombre de chiffres est diffrent de celui de la partie A)
o t[i,] = nb_app
o on met faux dans aig (on signale que la partie A a t modifie)
on incrmente Chiffre (attention si chiffre >9 on y met 0) (traitement du zro)
19 / 21
procedure AutorefA(var T:tab)

Variables aig : booleen
chiffre,i ,j , nb_app : Entier
fonction ComptVal
DEBUT
aig faux
tant que aig = faux faire
DTQ
Aig vrai
chiffre 1
Pour j allant de 1 2 faire
Pour i allant de 1 5 faire
DPOUR
nb_app COMPTVAL(T, 5, 5, chiffre)
Si T[i,j] <> nb_app Alors
DSI
T[i,j] nb_app
aig Faux
FSI
chiffre chiffre +1
Si chiffre > 9 Alors chiffre 0
FPOUR
FTQ
FIN
procedure AUTOREFA(var T:tab2);
// complete la partie A d'une grille autoreferente
var aig:boolean;
chiffre,i,j,nb_app:integer;
{$i E:\Algo\modules\comptVal.fon}
BEGIN
aig :=false;
while aig=false do
begin
aig:=true;
chiffre :=1;
for j:=1 to 2 do
for i := 1 to 5 do
begin
nb_app:= COMPTVAL(T,5,5,chiffre);
if T[i,j] <> nb_app then
begin
T[i,j] := nb_app;
aig:=false;
end;
chiffre := chiffre +1;
if chiffre >9 then chiffre :=0;
end;
end;
END;
20 / 21
ALGORITHME emd3_2004
type tab=Tableau [1..5,1..5] d'Entier

F = Fichier de tab
Variables i,j,valeur:Entier
FENETRE :tab
fic_A,Fic_b,Fic_R:F
DEBUT
assigner(Fic_A,'a:autoref_A.dat')
assigner(Fic_A,'a:autoref_B.dat')
assigner(Fic_R,'a:autoref.dat')
reset(fic_A)
reset(fic_B)
rewrite(Fic_R)
tant que eof(Fic_A) faire
DTQ
lire(fic_A,FENETRE)
AUTOREFA(FENETRE)
ecrire(Fic_R,FENETRE)
FTQ
Tant que eof(Fic_B) faire
DTQ
lire(fic_B,FENETRE)
AUTOREFB(FENETRE)
ecrire(Fic_R,FENETRE)
FTQ
fermer(Fic_B)
fermer(Fic_R)
FIN.
21 / 21

Exercice SR É Vison Ex Amen

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Exercice SR É Vison Ex Amen

Încărcat de

Drepturi de autor:

Formate disponibile

ESI CPI1 - Cours dAlgorithmique Exercices avec corrigs

Phrase donne : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

TYPE tab1= tableau [1..100] dentiers

On aura aussi besoin des fonctions standards ; Length(c) et Chr (x)

CONSTRUCTION DU MODULE DECMOTS

Procdure DecMots (c: Chane ; VAR T:tab3; VAR Nbm : Entier)

freq = 0 freq va contenir la frquence dapparitions du caractre L dans la chane C

CONSTRUCTION DE LALGORITHME PRINCIPAL

Ecrire ( 'Phrase donnee : ', tabp.ph)

Procedure Freqpos(c:string;L:char;var freq:integer;var Pos:tab1);

// Donne un tableau(POS) une dimension dont le 1er element contient la frequence

var i,k :longint;

Procedure DecMots(c:string;VAR T:tab3;VAR Nbm:integer);

Le dterminant de la matrice carre A(2,2) est DetA = (x11.x22 ) (x12.x21 )

Dans le cas gnral la formule du dterminant est :

A * Det (cofacteur ( A))

Exemple : si nous voulons calculer le dterminant de la matrice A dordre 3, ci-dessus :

Soit DetA = 1 * (0 48) 2 * (0 42) + 3 * (32 35) = - 48 + 84 9 = 27

Donc le dterminant de la matrice A donne est DetA = 27

Travail demand : Calcul du dterminant dune matrice carre dordre 3

On aura besoin des module suivants

Construction du module DET2

fonction Det2(a : tab2) : entier

Construction du module COFACT

On parcourt toutes les lignes et pour chaque ligne m

Construction du module DET3

Analyse : il suffit dappliquer la formule donne

Nota : comme i est gal 1, on le remplace par sa valeur

fonction det3 (t : tab2 ) : Entier

Construction de lalgorithme principal

(* --------- donne le determinant d'une matrice carree d'ordre 2 -------- *)

(* -- donne le cofacteur d'indices i,j (cof(lco,cco)) de la matrice T(l,c)-- *)

Dans la premire colonne de la partie A,

Dans la deuxime colonne de la partie A,

Le dcoupage comporte les modules suivants :

Nb : entier CompleteB T : Tab2

Rle : Complte le Tableau T (5,5) de faon ce que NB cases de T

fonction COMPTVAL(T:tab2 ; l, c, val : Entier):entier

procedure CompleteB (VAR T : tab2 ; nb ,chiffre : Entier)

procdure AUTOREFA(var T:tab)

// donne la frequence d'apparitions de la valeur Val dans le tableau T(l,c)

// Complete le tableau T(5,5) de facon a ce que Nb cases de T contiennent

// complete la partie B d'une grille autoreferente

Comment remplir la partie A dune grille autorfrente ?

CONSTRUCTION Du MODULE AutorefA

procedure AutorefA(var T:tab)

procedure AUTOREFA(var T:tab2);

// complete la partie A d'une grille autoreferente

type tab=Tableau [1..5,1..5] d'Entier

S-ar putea să vă placă și