On se propose de justifier un fichier texte écrit de façon aléatoire sur une ligne de longueur x en utilisant le langage C .
Avant de commencer, il faut savoir c'est quoi un texte justifié.
Un texte justifié : ajuster l'espacement vertical de sorte que tous les lignes du texte sont justifiées, c'est-à-dire, pour chaque ligne, son premier mot commence à la colonne 1 et que tous ses mots soient séparés par un nombre égal de blancs.
Méthode :
Cette méthode consiste a utilisé un tableau à deux dimensions (une matrice), et on met chaque ligne du texte dans une ligne du matrice, et on traite chaque ligne à part de manière a avoir un texte justifié sur une longueur donnée et tous les mots sont séparés par un nombre égale d'espace.
i <- 1
j <- 1
repeter
lire(f,c)
t[i][j] <- c
si(t[i][j]='\n')
i <- i+1
j <- 0
fin si
j <- j+1
jusqu'a(eof(f));
La manière de remplir la matrice par le fichier
Après avoir rempli la matrice, on fait tous les traitements sur la matrice et on oubli le fichier texte. Ensuite on supprime tous les espaces qui sont aux début et a la fin de chaque ligne de la matrice (la procédure supesp ). Donc, on a besoin de connaître le nombre de caractère dans une ligne, car le nombre caractère est variable, on utilise, donc, une fonction qui calcule le nombre de caractère (la fonction nbrcar ).
procedure supesp(var t,tab;ligne ,fin :entier)
var
i,nc:entier
debut
repeter
si(t[ligne][0]==' ') alors
pour i de 1 à nbrcar(t,ligne) faire
t[ligne][i] <- t[ligne][i+1]
fin si
jusqu'a(t[ligne][0]<>' ')
si(fin=1) alors
repeter
nc <- nbrcar(t,ligne)
si(t[ligne][nc-1]=' ')alors
t[ligne][nc-1] <- t[lign][nc]
fin si
jusqu'a(t[ligne][nc-1]<>' ')
fin si
Fin
La procédure de suppression des espaces dans une ligne
fonction nbrcar(t tab;ligne :entier) :entier
var
j,pn :entier
debut
j <- 1
pn <- 0
repeter
si(t[ligne][j]<>'\n') alors
pn <- pn+1
fin si
si(t[ligne][1]='\n') alors
pn <- 0
fin si
j <- j+1
jusqu'a(t[ligne][j-1]='\n')
nbrcar <- pn
Fin
La fonction qui compte le nombre de caractère dans une ligne
Après le remplissage du matrice par le texte et la suppression des espaces, on passe a la première étape de la justification : la procédure « justif1 ».
Cette procédure à pour but d'organiser dans chaque ligne du matrice un nombre maximale de mots :
• si le nombre de caractère dans une ligne dépasse la longueur désirer, on fait descendre un mot dans la ligne suivante (la procédure decalagehaut ) , et ainsi de suite.
• si le nombre de caractère dans une ligne est inférieur à la longueur désirer, on fait monter un mot de la ligne suivante (la procédure decalagebas ) , et ainsi de suite.
Et au cours de chaque opération sur les mots, on utilise plusieurs fonctions comme une fonction pour compter le nombre de caractère dans une ligne ( nbrcar ), compter la longueur d'un seul mot (mothaut & motbas ), déplacer un mot d'une ligne à une autre ( decalagehaut & decalagebas ), supprimer une ligne si elle ne contient aucun caractère ( monter_lignes ) .
Description de quelques fonctions qui me semble les plus délicat :
fonction motbas(t : tab;ligne :entier) :entier
var
j,let :entier
debut
let <- 0
j <- nbrcar(t,ligne)
repeter
si (t[ligne][j]<>' ') alors
let <- let+1
fin si
si (t[ligne][nbrcar(t,ligne)]=' ') alors
let <- let+1
fin si
j <- j-1
jusqu'a(t[ligne][j+1]=' ')
motbas<- let
Fin
La fonction « motbas » compte la longueur du dernier mot d'une ligne
(même chose pour « mothaut » )
procedure decalagehaut(t :tab ;ligne,nbrlet :entier)
var
i,pn :entier
debut
pn <- nbrcar(t,ligne)
t[ligne][pn+nbrlet] <-"\n"
pour i de 1 à nbrlet faire
t[ligne][pn+i] <- t[ligne+1][i]
fin pour
pn <- nbrcar(t,ligne+1)
pour i de 1 à pn-nbrlet faire
t[ligne+1][i] <- t[ligne+1][nbrlet+i]
fin pour
Fin
La procédure « decalagehaut » déplace un mot d'une ligne à la fin de la ligne précédente
procedure monter_lignes(t :tab ;ligne,nbrligne :entier)
var
j :entier
debut
repeter
pour j de 1 à nbrcar(t,ligne+1) faire
t[ligne][j] <- t[ligne+1][j]
fin pour
ligne <- ligne+1
jusqu'a(ligne>nbrligne)
Fin
La procédure « monter-lignes » supprime une ligne vide (contient 0 caractère )
Maintenant, et après organiser dans chaque ligne du matrice un nombre maximale de mots, on passe à la deuxième étape de la justification : la procédure « justif2 ».
Cette procédure à pour but d'ajuster l'espace entre les mots d'une ligne afin d'obtenir un texte justifié, et c'est la dernière étape de la justification d'un texte.
procedure justif2(t :tab ;longligne,nbrligne :entier)
var
lig,nc,dif,j,saut,nbesp :entier
debut
lig <- 1
nbesp <- 0
repeter
j <- 1
saut <- 1
nc <- nbrcar(t,lig)
dif <- longligne-nc
(* dif représente le nombre d'espace à ajouter *) si (nbrespace(t,lig)>=1) alors
si (dif>0) alors
repeter
si (t[lig][j]=' ') alors
nbesp <- nbesp+1
si (nbesp=saut) alors
decaler(t,lig,j)
nbesp <- 0
j <- j+1
dif <- longligne-nbrcar(t,lig)
fin si
fin si
j <- j+1
si (j>nbrcar(t,lig)) alors
j <- 0
saut <- saut+1
nbesp <- 0
fin si
jusqu'a(dif<=0)
fin si
sinon
lig <- nbrligne
fin si
lig <- lig+1
jusqu'a(lig>=nbrligne-1)
Fin
Explication :
Initialement, l'espace entre deux mots est 1 espace, et le nombre d'espace qu'il faut ajouter est : dif <- longligne-nc (longueur de la ligne désirer - le nombre de caractère), et la variable « saut » contient le nombre d'espace sur lequel on peut ajouter un autre espace.
Le principe est de faire un décalage de 1 à droite lorsque le nombre d'espace entre deux mots est égal à « saut » (on incrémente « saut » si on a arriver a la fin du ligne et « dif » est supérieur a 0), et de la cette façon, on ajoute un espace. Et on arrête à ajouter des espaces lorsque la variable « dif » est égale à 0, et on initialise « saut » a 1.
Et ainsi de suite, chaque ligne est traiter à part jusqu'on arrive a l'avant dernière ligne.
Finalement, on obtient un texte qui est justifié dans une matrice, et il ne reste que de lire de la matrice et d'écrire dans le fichier.
C'est simple comme idée, et les étudiant de la filière RT2 INSAT (2004/2005) le trouve facile.
Et pour mieux comprendre, voici le code source disponible on téléchargement avec un mot de passe .
Obtenir un mot de passe (free):
Poster sur mon livre d'or : écrire votre e-mail & mettre comme message « Mot de passe de justification d'un texte ».
Paramétrage de la fonction « main » :
Le paramétrage de la fonction « main » (ou programme principale), nécessite qu'il soit appelé par DOS. La fonction « main » peut être paramétrée par 2 paramètres :
• argc : il est de type numérique qui désigne le nombre de paramètre passés pour la fonction « main » : int argc .
• argv : est un tableau de chaines de caractères : char **argv OU char *argv[ ] .
Donc, le paramétrage de la fonction « main » de notre activité est :
void main( int argc, char *argv[] )
Et lorsqu'on appelle le programme avec DOS, on écrit le nom du programme suivi du chemin du fichier texte et la longueur de la ligne x.
