Vous êtes sur la page 1sur 20
Bonsai Tree Marwen Kchaou & Sofien Sfar Sup’Com
Bonsai
Tree
Marwen Kchaou & Sofien Sfar
Sup’Com
Bonsai Tree Marwen Kchaou & Sofien Sfar Sup’Com Projet programme C

Projet programme C

Remerciements La présente étude n’aurait pas été possible sans le bienveillant soutien de certaines personnes
Remerciements
La présente étude n’aurait pas été possible sans le bienveillant soutien de certaines
personnes et leur rôle déterminant dans la réalisation de ce projet. Pour cela, nous voudrions
les prier d’agréer du fond de nos cœurs toute notre gratitude.
Nos
premiers
remerciements
vont
d’abord
à
notre
établissement
universitaire
SUP’COM,
qui
nous
a
permis
à
travers
ce
module
d’enrichir
notre
formation
en
programmation voire notre aptitude à travailler en groupe.
Enfin, nous tenons à remercier chaleureusement les membres du jury pour l'honneur
qu'ils nous font en acceptant d'évaluer notre projet.
1

Sommaire

1

Introduction

3

2

Le cahier des charges

4

2.1 Objectifs

4

2.2 Les fichiers d’entrée sortie …………………………………………………

4

2.2.1

Input……………………………………………………………………………………………………………

4

2.2.2

Output…………………………………………………………………………………………………………….…

4

2.3 Structure de donnée utilisée

4

3

La démarche…………………………………………………………

5

4

Algorithme

6

4.1 Algorithmes des sous programmes

6

4.2 Algorithme du programme principal

8

5

Organigramme général du programme

11

5.1 Organigrammes des sous programmes

11

5.2 Organigramme du programme principal

16

6

Conclusion

18

7

Webographie

19

2

1) Introduction :

Rappel des objectifs

Réaliser un projet de programmation en langage C nous aide non seulement à maitriser le cours et les notions acquises en classe voire durant notre cursus scolaire et universitaire mais aussi à s’habituer au travail en groupe à la gestion du temps… qui attend indéniablement chaque futur ingénieur

.

Le projet consiste à résoudre un problème posé dans un sujet nommé Bonsai Tree en faisant un traitement sur un fichier Input et faire sortir le résultat dans un fichier Output

Afin de comprendre la démarche que nous avons utilisée pour mener ce projet à son terme, notre rapport se structure de la façon suivante :

Dans un premier lieu nous allons présenter le cadre général du projet, c'est -à-dire ce qui existe et ce que notre projet apportera. Dans un deuxième lieu, nous présenterons le travail d'étude et de recherche que nous avons effectué, en commençant par définir le cahier des charges. Enfin, dans la dernière partie, nous discuterons la concordance de nos résultats par rapport à nos objectifs initiaux et bien évidement un point de vue personnel s’impose.

Thème du mini-projet

Le mini-projet devra obligatoirement mettre en œuvre des structures de données persistantes

Dans ce contexte, il s’agira de réaliser pour ce sujet

Une lecture d’un jeu de données à partir d’un fichier texte

Un traitement sur ce jeu afin de résoudre le problème posé

Une écriture des résultats du traitement dans un fichier texte.

3

2)

Cahier des charges :

2. 1- Objectifs :

On se propose dans ce projet d’élaborer un programme en langage C qui permet d’enlever toutes les feuilles d’un arbre n-ainaire soit en coupant la feuille elle-même ou bien en coupant carrément la branche qui la porte et donc toutes les feuilles liées à cette dernière vont être enlevées à leurs tours. En mettant en tête que chaque liaison (feuille-branche ; branche- racine), le programme doit retourner le poids minimum des liaisons coupées afin que toutes les feuilles soient enlevées.

2. 2-Les fichiers d’entrée sortie :

2.2.1-Input

Le fichier d’input contient plusieurs cas de test. Chaque cas de test va commencer par une ligne

contenant une paire d’entier n et r (n ϵ [1

sommets dans l'arbre et l'indice du sommet racine. Les n-1 lignes suivantes contiennent chacune trois

entiers u i v i w i (où

u i , v i (u i , v i ϵ [1

w i . Le fichier d'entrée ne contiendra pas de nœuds en double. La fin du fichier est notée par une seule ligne contenant 0 0

1000])

et (r ϵ [1

n])

indiquant respectivement le nombre de

n])

et (w i ϵ [1

1000])

indiquant quele sommet u i est relié au sommet v i par un poid

2.2.1-Ouput

Le fichier de sortie doit contenir une seule valeur indiquant le poids minimum des liaisons devant être coupées afin que toutes les feuilles soient enlevées

2.4-Structure de donnée utilisée :

Afin de faciliter la tâche et d’améliorer la complexité de l’algorithme on a utilisé une structure de donnée dont on range les racines, les sous racine, et les poids des liaisons entre eux.

La structure « tree »

Tree.racine

Tree.weight

Tree.sou_racine

4

3) La démarche: élément de réflexion l’input du sujet 15 6 11 10 8 5
3)
La démarche: élément de réflexion l’input du sujet
15
6
11
10 8
5
7
5 3
13
9
6
2
4
3
2
3
4
5
2
1
14
12
8
11
7
4
3
1

L’idée est de parcourir l’arbre du bas et de comparer la somme des poids des branches des 2 sous racines et de la comparer avec la branche qui attache la racine de haut et choisir le minimum entre ces 2 valeurs pour obtenir enfin le minimum poids afin de supprimer la liaison du racine (15) avec toutes les feuilles avec le plus petit poids comme il nous est demandé.

Alors on a pensé tout d’abord à la structure la plus adéquate et la plus facile qu’on doit utiliser pour pouvoir atteindre notre but. Au début on a pensé à utiliser l’input (les 3 tableaux U,V et W) comme il est et on parcourt en premier temps U puis V mais on a trouvé un grand problème de point de vue raccordement entre les 3 tableaux et surtout au niveau des indices.

Donc on a pensé à une structure qui nous aidera à surmonter ce problème et c’était d’utiliser un tableau (nommé arbre) dans chaque case il y aura un petit tableau de 3 cases qui sont en ordre : racine / weight / sous_racine « structure de donnée » .L’idée est de remplir cet arbre en mettant tout d’abord dans les 2 premières case racine :=15et sous_racine1 :=10 , sous_racine2 :=5.Et après chaque sous_racine deviendra une racine dont on cherchera dans U et V ces sous_racines jusqu’à la fin de l’arbre.

On obtient la figure suivante :

15

6

5

15

11

10

10

5

13

10

8

9

5

3

2

5

7

6

6

5

4

6

4

7

 

2

1

1

2

2

3

9

2

8

9

3

11

13

4

14

13

3

12

NB : c’est un tableau de tableau et non pas une matrice .

5

Pour réussir le remplissage (qui est la plus dure tâche à faire) on a utilisé la procédure remplir qui à partir d’un r donné (considéré comme racine) on parcourt les tableaux U et V si il trouve pas la valeur qui est en liaison avec la racine r dans le tableau T (qui est un tableau initialiser à r , qui est la racine donnée en input, et reçoit les valeurs déjà mis dans l’arbre) alors il le met dans l’arbre en respectant que arbre[i].racine reçoit r , arbre[i].weight reçoit le poids entre r et sa sous_racine et arbre[i].sous_racine reçoit de toute évidence sous_racine

de r.

4) Algorithme:

4.1-Alghorithme des sous-programmes :

4.1.1-la fonction « occ »

Elle retourne le nombre d’occurrence d’un entier « val » dans un tableau « T » et de taille « r »

Fonction occ(val :entier, T :tab, r :tableau) :entier

Var i, occ1 : entier Début Occ1 := 0 Pour i de 1 à (r-1) faire Debut Si T[i]=val alors occ1 :=occ1+1

Fin

Fin ;

4.1.2-la procédure « remplir »

Elle remplit un tableau de structure « arbre » avec les racines les sous racine et le poids de leurs liaisons.

NB : la valeur k sera la taille du tableau arbre avec laquelle on peut suivre son avancement et la valeur j est celle du tableau T.

Procédure remplir(r ,k,j,n:entier,U,V,W,T :tab , arbre :tree )

Var i,j,k :entier

Début

Pour I de 1 à n faire

Si U[i]=r

6

alors

Si occ(V[i],T,r)==0

alors

arbre[K].racine:=U[i]

arbre[K].weight:=W[i]

arbre[K].sous_racine :=V[i]

K:=K+1

T[J]=V[i];

J=J+1;

Fin si

Si occ(V[i],T,r)==0

alors

arbre[K].racine:=V[i]

arbre[K].weight:=W[i]

arbre[K].sous_racine :=U[i]

Fin si

K:=K+1

T[J]=V[i];

J=J+1;

Fin si

Fin pour

Fin

4.1.3-la fonction « ind_weight »

Fonction ind_weight(arbre:tree ,x ,n:entier):entire

Var i: entire, trouve: Boolean

Debut

7

Trouve:=faux

Tanque (trouve=faux) ou (i=n-1) faire Debut

Si arbre[i].sous_racine=x alors touve :=vrai

Sinon i :=i+1

Fin

Fin ;

4.1.4-la procedure «lire_tab»:

Procédure lire_tab(dr U :vecteur d’entier , dr V : vecteur d’entier, dr W :vecteur d’entier , d n :entier ,d input :fichier) ;

Var i,j,k :entier ; Début

Pour i=0 haut n-1 faire Début

U[i] :=inpute^ ; prendre(inpute) ; V[i] :=inpute^ ; prendre(inpute) ; V[i] :=inpute^ ;

fin ;

Fin ;

4.1.5-la fonction «meme_racine»:

Cette fonction calcule d’un indice j donné le nombre de case du tableau arbre qui on pour racine la même racine que la case j d’autre terme et de point de vue arbre la fonction calcule le nombre de liaison que possède une racine.

Fonction meme_racine (d arbre :tree , d j :entier) :entier ; var i , s :entier ; chang :booléen ; Début

8

i :=j ; s :=0 ; chang :=faux ; tant que (chang=faux) faire Début si
i
:=j ;
s
:=0 ;
chang :=faux ;
tant que (chang=faux) faire
Début
si arbre[i].racine=arbre[i-1].racine
Début
s :=s+1 ;
i :=i-1
fin
sinon
Début
chang=1;
i :=i-1 ;
fin ;
meme_racine :=s
fin ;
4.1.6-la fonction «somme»:
Cette fonction calcule la somme des poids des branches qui ont la même racine.
Fonction somme (d arbre :tree , d j :entier , meme :entier) :entier ;
var
i,s :entier;
Début
i
:=j-1 ;
s
:=arbre[j].weight;
tant que (i>=j-meme+1)
début
s :=arbre[i].weight+s ;
i :=i+1
fin ;
somme :=s ;
fin ;
4.2-Alghorithme du programme principal :
Var
T,U,V,W :vecteur [1
1000]
d’entier ;
j , k, c , n , h , i , min , ind , x , s , r , N :entier ;
Début
9

n :=N-1 ;

relire(input) ;

recrire(output) ;

tant que ( fdf(input)=faux) faire

n :=input^ ;

prendre(input) ;

m :=input^

prende(input) ;

début

T[0] :=r ; lire_tab(U,V,W,n,input) ;

k

j

:=0 ;

:=1 ;

remplir(r , k , j , n , U , V , W , arbre) ;

c :=0 ;

tant que (k<n-1) faire

debut

h :=k;

pour i=h-1 bas c (pas=-1) faire

remplir(arbre[i].sous_racine,k,j,n,U,V,W,T,arbre);

c :=h

fin ; m :=-1; pour j de n-1 bas 2 (pas=-1) début

si (arbre[j].racine<>m) alors

début

meme :=meme_racine(arbre,j) ; m :=arbre[j].racine ;

si (meme>1) alors

début min :=somme(arbre,j,meme) ;

x :=arbre[j].racine ;

ind :=ind_weight(arbre,x);

si (arbre[ind].weight)>min alors arbre[ind].weight :=min

s :=(arbre[0].weight)+(arbre[1].weight);

output^ :=s ; mettre(s) ; fin ;

fin ;fin;fin;

10

5) Organigramme général du programme :

5. 1- Organigramme des sous programmes :

5.1.1-la fonction « occ » :

5) Organigramme général du programme : 5. 1- Organigramme des sous programmes : 5.1.1-la fonction «

11

5.1.2-la procédure « remplir » :

5.1.2-la procédure « remplir » : 12
5.1.2-la procédure « remplir » : 12

12

5.1.3-la fonction « ind_weight »:

5.1.3-la fonction « ind_weight »: 13

13

5.1.4-la procédure «meme racine » :

5.1.4-la procédure «meme racine » : 14

14

5.1.5-la procédure « somme » :

5.1.5-la procédure « somme » : 15

15

5.2-Organigramme du programme principal :

5.2-Organigramme du programme principal : 16

16

17

17

6) Conclusion :

Ce mini-projet nous a permet non seulement de consolider les notions de programmation et surtout ceux du langage C, acquises en classe « practice makes perfect », mais aussi et ce qu’on considère le plus important c’est de nous initier au monde professionnel celui de l’ingénieur qui est toujours confronté à des situations pareilles qui nous apprennent comment gérer notre temps et comment user efficacement nos neurones et les pousser au-delà des limites. De plus nous ne pouvons pas nier l’importance d’un tel projet à améliorer notre aptitude pour le travail en groupe.

18