Etablir un programme en langage C permettant de lire un fichier texte

**hardivirginie** · 07/06/2014, 17h53

Bonjour,
Bin voilà ...J'ai exam mardi et je suis complètement larguée pour ma prépa.
Voila ce que je dois coder;

Etablir un programme en langage C permettant de lire un fichier texte contenant une liste de mots.<ok>
Un mot par ligne.<ok>
Le programme ne traite que les mots d'une taille <= 10 caractères.<ok>
Pour chaque mot retenu, le programme génère un deuxième mot composé des lettre du mot lu.
Ces lettres sont triées alphabétiquement.
Le couple mot + mot trié est mémorisé dans une structure.
La structure est mémorisée dans un vecteur trié par taille des mots.
Lorsque tous les mots sont traités, le programme crée un deuxième fichier texte.
dans lequel sera copié la liste des mots.
Chaque ligne de ce nouveau fichier texte sera composée de:
mot;mot trié.
Le programme doit être réalisé en moins de 2 heures.

Pour les trois premières consignes aucun problème mais pour la quatrième...Je sais trier le fichier ligne par ligne et par ordre alphabétique mais pas les mots ...
Je suis a bout et dessus depuis 11h du math essayant de trouver des solutions

sur internet mais rien qui puissent m'aider.

Heeeeeeeeeeeeeeeeeeeelp...

**Obsidian** · 07/06/2014, 21h42

Bonjour et bienvenue,

D'un côté, c'est un exercice vraiment tordu. Tu dis que tu sais « trier le fichier ligne par ligne ». Quelle méthode utilises-tu ?

Pour tes mots, commence déjà par définir la structure qui doit les contenir. Si tu es sûre qu'ils ne sont longs que de dix caractères maximum, tu peux écrire quelque chose dans le style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
struct mot
{
    char original[11];
    char trie[11];
};

… en réservant un caractère supplémentaire (onze en tout, donc) pour le zéro final.

Pour trier tes caractères, tu peux te permettre de faire un tri à bulles. Même si c'est réputé globalement peu efficace, c'est ce qu'il y a de plus simple sur de petits ensembles de caractères comme le tien. Il s'agit simplement de lire les dix caractères de gauche à droite, de comparer chaque caractère avec le suivant, de les permuter si le suivant est « inférieur » au caractère courant et de recommencer autant de fois que nécessaire, c'est-à-dire tant que tu as permuté au moins un caractère.

**hardivirginie** · 08/06/2014, 11h57

Bonjour,

Merci d'avoir répondu ,je vais pouvoir me débrouiller avec ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
///////////////////////////////////////////////////////////////////////////////
#define MAX_TAILLE  10      // Définir la taille maximale d'un mot
///////////////////////////////////////////////////////////////////////////////
 
// Structure contenant le mot et son mot trié
typedef struct MOT
{
    char Mot[MAX_TAILLE + 1];
    char MotTrie[MAX_TAILLE + 1];
} MOT;
///////////////////////////////////////////////////////////////////////////////
 
// Déclaration des fonctions
MOT * LireFichier(FILE * Fichier,int *NbElem);
int SauverTableau(MOT Tableau[],int NbElem);
int VerifierLigne(char Ligne[]);
MOT * AjouterMot(char Mot[],MOT *Tableau,int *NbElem);
void TrierMot(char Mot[]);
int ComparerChar(const void *p1,const void *p2);
int ComparerMot(const void *p1,const void *p2);
void TrierTableau(MOT Tableau[],int NbElem);
///////////////////////////////////////////////////////////////////////////////
 
// Fonction main
int main()
{
    char    NomFichier[512]     = {0};
    FILE    *Fichier            = NULL;
    MOT     *Tableau            = NULL;
    int     NbElem              = 0;
 
    printf("Correction de la preparation!\n");
 
    // Ouverture du fichier
    printf("Entrez le nom d'un fichier: ");
    fflush(stdin);
    gets(NomFichier);
 
    Fichier = fopen(NomFichier,"r");
 
    if(Fichier == NULL)
    {
        perror("Erreur d'ouverture du fichier: ");
        exit(1);
    }
 
    // Lecture des mots du fichiers et génération du vecteur
    Tableau = LireFichier(Fichier,&NbElem);
 
    // Fermeture du fichier
    fclose(Fichier);
 
    if(Tableau == NULL)
    {
        printf("Pas de mots dans le fichier\n");
    }
    else
    {
        // Trier le tableau
        TrierTableau(Tableau,NbElem);
 
        // Sauver le tableau
        if(SauverTableau(Tableau,NbElem) == 0)
        {
            printf("Erreur de sauvegarde du tableau\n");
        }
    }
 
    return 0;
}
///////////////////////////////////////////////////////////////////////////////
 
// Fonction de lecture du fichier générant un tableau de MOT
MOT * LireFichier(FILE *Fichier,int *NbElem)
{
    char    Ligne[512]  = {0};
    char    *Fin        = NULL;
    MOT     *Tableau    = NULL;
    int     Continuer   = 1;
 
    *NbElem = 0;    // Remise à zéro du nombre de MOT
 
    // Lire une ligne
    fgets(Ligne,sizeof(Ligne),Fichier);
 
    while(!feof(Fichier) && Continuer == 1)         // boucle tant qu'il y a une ligne ET que Continuer est TRUE (1)
    {
        // Retirer le \n éventuel
        Fin = strrchr(Ligne,'\n');
 
        if(Fin != NULL)
            *Fin = '\0';
 
        if(VerifierLigne(Ligne) == 1)
        {   // La ligne est bonne
            Tableau = AjouterMot(Ligne,Tableau,NbElem);
 
            if(Tableau == NULL)
            {   // Une erreur d'ajout du mot a eu lieu donc le pointeur Tableau == NULL
                Continuer = 0;  // Donc Continuer = FALSE (0)
            }
        }
 
        fgets(Ligne,sizeof(Ligne),Fichier);
    }
 
    return Tableau;
}
///////////////////////////////////////////////////////////////////////////////
 
// Vérification que la ligne a une taille <= 10 ET que la ligne ne contient que les lettre de a à z (en minuscule)
int VerifierLigne(char Ligne[])
{
    int Retour = 0;
    int Taille = strlen(Ligne);
    int I = 0;
 
    if(Taille <= MAX_TAILLE)
    {   // La taille est bonne
        Retour = 1;
 
        // Tester que les caractères sont compris entre a et z
        for(I = 0;I < Taille && Retour == 1;++I)
        {
            if(Ligne[I] < 'a' || Ligne[I] > 'z')
            {   // Le caractère n'est pas compris entre a et z
                Retour = 0;
            }
        }
    }
 
    return Retour;
}
///////////////////////////////////////////////////////////////////////////////
 
// Ajouter un mot dans le tableau
MOT * AjouterMot(char Mot[],MOT * Tableau,int *NbElem)
{
    int N = *NbElem;
 
    // Allocation d'un nouvel élément
    if(Tableau == NULL)
    {
        Tableau = (MOT*)malloc(sizeof(MOT));
    }
    else
    {
        Tableau = (MOT*)realloc(Tableau,sizeof(MOT) * (N + 1));
    }
 
    // Echec ou non
    if(Tableau == NULL)
    {
        printf("Erreur d'allocation du tableau\n");
    }
    else
    {   // Copie du mot dans la structure
        strcpy(Tableau[N].Mot,Mot);
        strcpy(Tableau[N].MotTrie,Mot);
        ++N;
 
        // Trier le mot à trier
        TrierMot(Tableau[N].MotTrie);
 
        *NbElem = N;
    }
    return Tableau;
}
///////////////////////////////////////////////////////////////////////////////
 
// Fonction permettant de trier les lettres d'un mot
void TrierMot(char Mot[])
{
    int Taille = strlen(Mot);
 
    qsort(Mot,Taille,sizeof(char),ComparerChar);
 
    // Utilisation de la fonction qsort native du C
    // Param1: Vecteur de caractère contenant le mot
    // Param2: Nombre de caractères dans le mot
    // Param3: Taille d'un élément du vecteur (donc ici un sizeof(char))
    // Param4: Fonction appelée pour comparer chaque élément du vecteur
}
///////////////////////////////////////////////////////////////////////////////
 
// Comparer deux caractères
int ComparerChar(const void *p1,const void *p2)
{
    char *c1 = (char*)p1;   // Conversion d'un pointeur de nature const void* en pointeur char*
    char *c2 = (char*)p2;
 
    // Comparer la valeur des deux caractères. La valeur de retour est calquée sur strcmp
    if(*c1 < *c2)   return -1;      // 'a' < 'b'    --> -1
    if(*c1 > *c2)   return 1;       // 'b' > 'a'    --> 1
    return 0;                       // 'a' == 'a'   --> 0
}
///////////////////////////////////////////////////////////////////////////////
 
// Trier le tableau de MOT sur base de la taille de chaque mot
void TrierTableau(MOT Tableau[],int NbElem)
{
    qsort(Tableau,NbElem,sizeof(MOT),ComparerMot);
    //Param1: Tableau de mot
    //Param2: Nombre d'éléments dans le tableau
    //Param3: Taille d'un élément du tableau (ici sizeof(MOT))
    //Param4: Fonction appelée pour comparer chaque élément du tableau
}
///////////////////////////////////////////////////////////////////////////////
 
// Fonction permettant de comparer la taille de deux mots
int ComparerMot(const void *p1,const void *p2)
{
    MOT *m1 = (MOT*)p1; // Conversion d'un pointeur de nature const void* en pointeur MOT*
    MOT *m2 = (MOT*)p2;
 
    int T1 = strlen(m1->Mot);   // Mémoriser la taille des mots
    int T2 = strlen(m2->Mot);
 
    if(T1 < T2) return -1;
    if(T1 > T2) return 1;
    return 0;
}
///////////////////////////////////////////////////////////////////////////////
 
// Sauvegarder le tableau dans un fichier
int SauverTableau(MOT Tableau[],int NbElem)
{
    char NomFichier[512];
    FILE *Fichier = NULL;
    int I;
 
    // Saisie du nom du fichier de sortie
    printf("Entrer le nom du fichier resultat: ");
    fflush(stdin);
    gets(NomFichier);
 
    // Ouverture du fichier en écriture --> Création du fichier
    Fichier = fopen(NomFichier,"w");
 
    // Test de création du fichier
    if(Fichier == NULL)
    {
        perror("Erreur de creation du fichier: ");
        return 0;   // La fonction ne s'est pas bien déroulée
    }
 
    // Ecrire chaque élement MOT dans le fichier
    for(I = 0;I < NbElem;++I)
    {
        if(I > 0)
            fprintf(Fichier,"\n");
 
        fprintf(Fichier,"%s;%s",Tableau[I].Mot,Tableau[I].MotTrie);
    }
 
    // Fermeture du fichier
    fclose(Fichier);
 
    return 1;   // La fonction s'est bien déroulée
}
///////////////////////////////////////////////////////////////////////////////

Voici la correction de mon prof .
Y a-t-il moyen d'optimiser ce code?

**dinobogan** · 10/06/2014, 17h43

Envoyé par hardivirginie

Y a-t-il moyen d'optimiser ce code?

Le mot "optimiser" est souvent utiliser de travers.
Quel sens lui donnes-tu ? Diminuer l'usage de :
- la RAM ?
- les accès disques ?
- la charge CPU ?
- une ou plusieurs autres ressources ?
- le temps d'exécution sans compter l'initialisation et les pré-chargement et autres pré-calculs ?
- le temps d'exécution complet depuis le lancement du programme jusqu'à son arrêt ?

Pour une architecture et une implémentation correcte, il n'est pas possible d'améliorer tous ces points en même temps.

Etablir un programme en langage C permettant de lire un fichier texte

C

Discussions similaires

Partager

Partager