Discussion :

[BartRoX]

Bonjour

J'ai un problème simple, mais je ne sais pas trop comment m'y prendre.

J'ai un fichier .txt avec une chaine de caractère récurrente que j'aimerais remplacer par une autre chaine de caractère.

En gros, admettons que dans un fichier .txt où y'a plein de truc d'écrit, y'a la chaine "toto" qui revient souvent, et j'aimerais remplacer tous ces toto par des "newChaine", vous voyez l'truc ?

Bien entendu le plus compliqué n'est pas vraiment de remplacer la chaine, mais plutôt de récuperer puis réenregistré dans le ficher .txt

[stroke]

Bonsoir.

En fait tu ne remplaces pas la chaine dans le fichier original, tu crées un nouveau fichier dans lequel tu recopies le premier fichier avec les chaines modifiées. Tu supprimes le premier fichier et tu renommes le nouveau avec le nom de l'ancien.

[BartRoX]

Oui, si tu veux, mais ca encore c'est un détail. La question c'est comment je fais ?

[Neckara]

Je n'ai pas beaucoup réfléchit, mais si tu lisais ton fichier octet par octet et que tu stocke tout dans une liste doublement chaînée de caractère et qu'ensuite tu parcours ta chaîne et dès que tu rencontre le premier caractère de ton mot cherché, tu :
- stocke le pointeur sur le maillon
- tu lis caractère par caractère voir si ceci correspond à ta chaîne
- si oui, tu remplace très facilement la chaîne
- si non, tu reviens à ton maillon grâce au pointeur préalablement enregistré et tu continus.

Exemple :

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
 
char chaîne[max];
int i = 0;
while(i != max)
{
           if( maillon && chaine[i] == maillon->c)
           {
                     maillon = maillon->suivant;
                      i++;
           }
            else
                      return NULL;
 
}
return maillon;

Donc si cette fonction retourne NULL, tu continus.
Sinon tu supprime de ton maillon courant au maillon retourné puis tu insère la nouvelle chaine de caractère.

[Trademark]

Salut,

Peut-être en utilisant simplement un tableau de caractère ça pourrait le faire. Tu stockes ton fichier dans un premier tableau de char. Tu alloues un deuxième tableau au moins de la taille du premier.

L'algorithme naif, et le plus simple, c'est de parcourir le premier tableau et pour chaque caractère, tu regardes si la suite correspond à la chaine que tu veux remplacer. Si non tu écris le caractère et tu avances de 1, si oui tu écris ton nouveau mot et tu avances de la taille de l'ancien mot dans le premier tableau.

Cet algo n'est peut-être pas tout à fait juste, je ne l'ai pas testé ! C'est pour te donner une idée d'implémentation.

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
int main()
{
  char* tab1 = malloc(taille_du_fichier); // voir la faq C pour récupérer la taille du fichier.
 
  char* tab2 = malloc(taille_du_fichier);
 
  for(int i=0, j=0; i < taille_du_fichier;)
  {
     int match = 1, k;
     for(k= 0; k < taille_mot_a_rechercher && match && (i+k) < taille_du_fichier; ++k)
       match = tab1[i + k] == mot_a_rechercher[k];
 
    // Attention au dépassement de buffer de tab2, il faut que tu ré-alloues si besoin !! (C'est seulement possible si la chaine à remplacer est plus courte que la nouvelle chaine).
    if(match && k == taille_mot_a_rechercher)
    {
       for(k = 0; k < taille_mot_remplacant; ++k)
         tab2[j+k] = mot_remplacant[i+k];
       j += taille_mot_remplacant;
       i += taille_mot_a_rechercher;
    }
    else
    {
       tab2[j++] = tab1[i++];
    }
  }
}

C'est l'algo naif car il peut être en O(n²).

Pour la complexité spaciale (l'espace qu'occupera ton programme en mémoire vive), je n'ai pas trop d'idée d'amélioration à part ne pas copier tout le fichier en mémoire et copier seulement morceaux par morceaux.

Par contre, pour la complexité temporelle, tu peux tenter d'implémenter l'algorithme de recherche de pattern de KMP, regarde sur internet, il est plus performant.

Bonne chance

[diogene]

L'inconvénient, est qu'il n'y a aucun moyen de déterminer la taille à choisir pour le tableau 2 si la chaine de remplacement est plus longue que la chaine à remplacer.

J'envisagerai plutôt de le faire fichier à fichier :

T, un tableau contenant la chaine à remplacer comportant N caractères.
ix, un index sur ce tableau
- ix =0
- Faire :
      - lire le caractère suivant du fichier source
      - Si la fin de fichier n'est pas atteinte :
           - Si le caractère lu n'est pas égal à T[ix] :
                 - copier les éléments de T de 0 à ix-1 ; mettre ix à 0
           - Si le caractère lu est égal à T[ix] :
                 - incrémenter ix. 
                 - Si ix == N :
                      - copier la chaine de remplacement ;  mettre ix à 0      
           - Sinon :  
                 - copier le caractère       
  Tant que la fin de fichier n'est pas atteinte
- Copier les éléments de T de 0 à ix-1