Discussion :

[kerrons]

Bonsoir ,
Soit un fichier « mots.txt » contenant des mots, écrire un programme qui permet de trouver les palindromes, de les écrire dans un autre fichier « palindrome.txt » et d’afficher leur nombre.
J'ai écrit un programme pour cet exercice mais l'exécution bloque comme l'indique cette image

Pourriez vous m'aider à trouver le problème s'il vous plait et merci .

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
#include <stdio.h>
#include <stdlib.h>
int nombre(FILE *f1)// retourne le nombre de mots dans un fichier
{ int a=0;
  int b=0;
  int i=0;
     do
      {
          a=fgetc(f1);
          b=fgetc(f1);
          fseek(f1,-1,SEEK_CUR);
 
          if(((a == ' ')||(a == '\n'))&&(b!=' ')&&(b!='\n'))
          {
              i++;
 
          }
      }while(b!=EOF);
      i++;
     return i;
   }
int palindrome(int n,char ch[n])//retourne 1 si le mot est palindrome 0 sinon
{
int a=1;
for (int i=0;i<(n/2);i++)
{
    if (ch[i]!=ch[n-i-1])
    {
 
        a=0;
 
    }
}
return a;
}
 
 
 
int main()
{
    int c=0;
    FILE *f1=NULL;
    FILE *f2=NULL;
    f1=fopen("mots.txt","r");
    f2=fopen("palindrome.txt","a");
    if ((f1==NULL)||(f2==NULL))
    {
        printf("erreur d'ouverture");
    }
    else
    {
     do
      {
        int j=0;
 
        do  //cette boucle permet de déterminer la longeur de chaqu'un des mots du fichier
          {
              c=fgetc(f1);
              j++;
          }while ((c!=' ')||(c!='\n'));
 
        fseek(f1,-j,SEEK_CUR);//Pour faire retourner le cursor vers le début du mot qui précede le 1er espace ou retour à la ligne rencontré.
        char *T=malloc(j*sizeof(char));
 
        for(int i=0;i<j;i++)//mettre le mot trouvé dans un tableau et remettre le cursor à la position avec laquelle il a quitté la boucle do
          {
              T[i]=fgetc(f1);
          }
 
         if(palindrome(j,T)==1)// vérifier si le mot est palindrome et le mettre dans f2 si c'est le cas
          {
              fputs(T,f2);
          }
 
      }while (c!=EOF);
    printf("Le nombre des mots palindromes est %d \n :",nombre(f2));
    }
    fclose(f1);
    fclose(f2);
 
}

[dalfab]

Bonjour,

ligne 60, le code reboucle pour les caractère différent de espace ou bien différent de retour chariot. Tous les caractères du monde vérifient cela (y compris espace et retour chariot!).
Il y a des malloc() mais jamais de free ...

[kerrons]

Bonjour,

(y compris espace et retour chariot!).
Il y a des malloc() mais jamais de free ...

Vous avez raison j'oublier toujours de libérer mes allocations dynamiques mais même en faisant cela le programme ne fonctionne pas par contre en ce qui concerne la ligne 60 si on suppose que le fichier ne contient que des caractères alphabétiques ,des espaces et des retours à la ligne la sortie de la boucle do sera faite seulement si le caractère est un espace ou un retour à la ligne.
update du code

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
#include <stdio.h>
#include <stdlib.h>
int nombre(FILE *f1)// retourne le nombre de mots dans un fichier
{ int a=0;
  int b=0;
  int i=0;
     do
      {
          a=fgetc(f1);
          b=fgetc(f1);
          fseek(f1,-1,SEEK_CUR);
 
          if(((a == ' ')||(a == '\n'))&&(b!=' ')&&(b!='\n'))
          {
              i++;
 
          }
      }while(b!=EOF);
      i++;
     return i;
   }
int palindrome(int n,char ch[n])//retourne 1 si le mot est palindrome 0 sinon
{
int a=1;
for (int i=0;i<(n/2);i++)
{
    if (ch[i]!=ch[n-i-1])
    {
 
        a=0;
 
    }
}
return a;
}
 
 
 
int main()
{
    int c=0;
    FILE *f1=NULL;
    FILE *f2=NULL;
    f1=fopen("mots.txt","r");
    f2=fopen("palindrome.txt","a");
    if ((f1==NULL)||(f2==NULL))
    {
        printf("erreur d'ouverture");
    }
    else
    {
     do
      {
        int j=0;
 
        do  //cette boucle permet de déterminer la longeur de chaqu'un des mots du fichier
          {
              c=fgetc(f1);
              j++;
          }while ((c!=' ')||(c!='\n'));
 
        fseek(f1,-j,SEEK_CUR);//Pour faire retourner le cursor vers le début du mot qui précede le 1er espace ou retour à la ligne rencontré.
        char *T=malloc(j*sizeof(char));
 
        for(int i=0;i<j;i++)//mettre le mot trouvé dans un tableau et remettre le cursor à la position avec laquelle il a quitté la boucle do
          {
              T[i]=fgetc(f1);
          }
 
         if(palindrome(j,T)==1)// vérifier si le mot est palindrome et le mettre dans f2 si c'est le cas
          {
              fputs(T,f2);
          }
          free(T);
 
      }while (c!=EOF);
    printf("Le nombre des mots palindromes est %d \n :",nombre(f2));
    }
    fclose(f1);
    fclose(f2);
 
}

[dalfab]

en ce qui concerne la ligne 60 si on suppose que le fichier ne contient que des caractères alphabétiques ,des espaces et des retours à la ligne la sortie de la boucle do sera faite seulement si le caractère est un espace ou un retour à la ligne.

Non, on ne sortira de la boucle que si le caractère est à la fois une espace et un retour à la ligne. Ce qui est évidemment impossible. relis toi bien.

[kerrons]

J'ai changé la condition de sortie toujours même problème .

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
 
#include <stdio.h>
#include <stdlib.h>
int nombre(FILE *f1)// retourne le nombre de mots dans un fichier
{ int a=0;
  int b=0;
  int i=0;
     do
      {
          a=fgetc(f1);
          b=fgetc(f1);
          fseek(f1,-1,SEEK_CUR);
 
          if(((a == ' ')||(a == '\n'))&&(b!=' ')&&(b!='\n'))
          {
              i++;
 
          }
      }while(b!=EOF);
      i++;
     return i;
   }
int palindrome(int n,char ch[n])//retourne 1 si le mot est palindrome 0 sinon
{
int a=1;
for (int i=0;i<(n/2);i++)
{
    if (ch[i]!=ch[n-i-1])
    {
 
        a=0;
 
    }
}
return a;
}
 
 
 
int main()
{
    int c=0;
    FILE *f1=NULL;
    FILE *f2=NULL;
    f1=fopen("mots.txt","r");
    f2=fopen("palindrome.txt","a");
    if ((f1==NULL)||(f2==NULL))
    {
        printf("erreur d'ouverture");
    }
    else
    {
     do
      {
        int j=0;
 
        do  //cette boucle permet de déterminer la longeur de chaqu'un des mots du fichier
          {
              c=fgetc(f1);
              j++;
          }while ((64<c<91)||(96<c<123));
 
        fseek(f1,-j,SEEK_CUR);//Pour faire retourner le cursor vers le début du mot qui précede le 1er espace ou retour à la ligne rencontré.
        char *T=malloc(j*sizeof(char));
 
        for(int i=0;i<j;i++)//mettre le mot trouvé dans un tableau et remettre le cursor à la position avec laquelle il a quitté la boucle do
          {
              T[i]=fgetc(f1);
          }
 
         if(palindrome(j,T)==1)// vérifier si le mot est palindrome et le mettre dans f2 si c'est le cas
          {
              fputs(T,f2);
          }
          free(T);
 
      }while (c!=EOF);
    printf("Le nombre des mots palindromes est %d \n :",nombre(f2));
    }
    fclose(f1);
    fclose(f2);
 
}

[dalfab]

On veut sortir de la boucle si le caractère est une espace ou bien un retour chariot.
Donc on veut rester dans la boucle si le caractère n'est pas une espace et n'est pas non plus un retour chariot.

Le test était faux, maintenant while ((64<c<91)||(96<c<123)); n'a plus aucun sens et est illisible mais maintenant il faut bien un ou car on boucle si minuscule ou majuscule. Il faudrait while ( ('a'<=c && c<='z') || ('A'<=c && c<='Z') ); ou bien while ( c !=' ' && c != '\n' );.

Cette boucle va lire un caractère de plus que la longueur du mot; Valeur qui est dans j. Il donc bien reculer de j et réserver un caractère de plus pour le terminateur dans le malloc. Mais après avoir lu j caractères il faut remplacer le dernier par un '\0' sinon le puts(T) ne fonctionnera pas. Et la longueur à passer à palindrome est la longueur du mot donc j-1;

[Sve@r]

Bonjour

Vous avez raison j'oublier toujours de libérer mes allocations dynamiques mais même en faisant cela le programme ne fonctionne pas

Oublier de libérer n'empêche pas le programme de fonctionner. Et rajouter la libération manquante ne rend pas fonctionnel un programme qui ne l'était pas.

C'est simplement une bonne habitude à prendre pour

• éviter la perte de mémoire qui n'est pas vraiment un souci sur Unix (car il libère lui-même la mémoire allouée à la fin du processus) et qui ne l'est plus non plus sous Windows (pour les mêmes raisons) mais qui, à une époque pas si lointaine, l'était car (à cette époque) une mémoire non libérée était alors définitivement perdue et nécessitait un reboot de la machine. Et qui peut toutefois devenir quand-même un souci si ton programme est porté sur un autre OS.
• éviter le crash dû à une allocation en boucle jamais libérée

J'ai changé la condition de sortie toujours même problème .

On veut sortir de la boucle si le caractère est une espace ou bien un retour chariot.
Donc on veut rester dans la boucle si le caractère n'est pas une espace et n'est pas non plus un retour chariot.

Un mathématicien nommé "De Morgan" a établi les lois qui permettent d'inverser une condition (dites lois de "De Morgan"). Elles ne sont pas très compliquées et peuvent d'ailleurs se déduire des tables de vérité de base (OU, ET et NON).
Elles sont:

• NON(A OU B) = NON(A) ET NON(B)
• NON(A ET B) = NON(A) OU NON(B)

Elles peuvent aussi se retrouver grâce à la réflexion. Si par exemple je veux un nombre compris entre 10 et 20 (donc >= 10 ET <= 20), alors le contraire c'est un nombre qui n'est pas compris entre 10 et 20 (donc < 10 OU > 20). Et si je veux un nombre divisible par 3 OU par 5 alors le contraire sera un nombre non divisible par 3 ET non divisible par 5.

Accessoirement il est parfois courant de voir écrit "interdit de faire ceci et cela", texte écrit manifestement par quelqu'un qui ne connait pas ces fameuses lois car un tel texte interdit l'ensemble mais permet toutefois de faire ceci si on ne fait pas cela et inversement. Alors que la formulation correcte correspondant à l'idée qu'on peut deviner chez l'auteur devrait être "interdit de faire ceci ou cela" signifiant alors "interdit de faire ceci ET interdit de faire cela". Maintenant un tel argumentaire serait-il accepté par une instance qui nous reprocherait éventuellement l'infraction...?

[kerrons]

J'ai modifié le code encore une fois le programme s’exécute mais il y a 3 problèmes .D'abord j'ai ajouter des printf pour pouvoir contrôler les enregistrement 1 à 1 j'ai remarqué que il y a un décalage dans le dernier mot uniquement un espace qui se mets en avant . Deuxièmement j'ai réecrit la fonction nombre d'une manière plus adaptée au programme car j'ai ajouté un espace au fichier de sortie après chaque mot mais la fonction nombre ne fonctionne plus (elle retourne 0).Et dernièrement l'écriture dans le fichier est parfaite lors de la première exécution mais à partir de la deuxième si j'essaye de ré exécuter le programme il y a des espaces et des retours ) la ligne qui s'ajoutent n'importe comment .

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
 
#include <stdio.h>
#include <stdlib.h>
int nombre(FILE *f1)// retourne le nombre de mots dans un fichier
{ int a=0;
 
  int i=0;
     do
      {
          a=fgetc(f1);
 
 
        if(a==' ')
          {
              i++;
 
          }
      }while(a!=EOF);
 
     return i;
   }
int palindrome(int n,char ch[n])//retourne 1 si le mot est palindrome 0 sinon
{
int a=1;
for (int i=0;i<(n/2);i++)
{
    if (ch[i]!=ch[n-i-1])
    {
 
        a=0;
 
    }
}
return a;
}
 
 
 
int main()
{
    int c=0;
    FILE *f1=NULL;
    FILE *f2=NULL;
    f1=fopen("mots.txt","r");
    f2=fopen("palindrome.txt","a");
    if ((f1==NULL)||(f2==NULL))
    {
        printf("erreur d'ouverture");
    }
    else
    {
     do
      {
        int j=0;
 
        do  //cette boucle permet de déterminer la longeur de chaqu'un des mots du fichier
          {
 
              c=fgetc(f1);
              j++;
          }while ( ('a'<=c && c<='z') || ('A'<=c && c<='Z') );
 
        fseek(f1,-j,SEEK_CUR);//Pour faire retourner le cursor vers le début du mot qui précede le 1er espace ou retour à la ligne rencontré.
        char *T=malloc((j)*sizeof(char));
 
        for(int i=0;i<j;i++)//mettre le mot trouvé dans un tableau et remettre le cursor à la position avec laquelle il a quitté la boucle do
          {
              T[i]=fgetc(f1);
              printf("T[%d]=%c\n",i,T[i]);
          }
            T[j-1]='\0';
          printf("T=%s \n",T);
 
         if(palindrome(j-1,T)==1)// vérifier si le mot est palindrome et le mettre dans f2 si c'est le cas
          {
              fputs(T,f2);
              fputc(' ',f2);
          }
          free(T);
 
      }while (c!=EOF);
    printf("Le nombre des mots palindromes est : %d \n ",nombre(f2));
    }
    fclose(f1);
    fclose(f2);
 
}

[Sve@r]

Tu ne voudrais pas aussi nous mettre un exemple du fichier input qu'on voit comment il est fait et qu'on puisse tester de notre côté ?
Accessoirement le paramètre "n" dans "palindrome()" est inutile vu qu'il peut se calculer depuis "ch". De plus je ne vois nulle part comment tu gères le '\n' terminant toute ligne (dans un fichier texte s'entend) mais n'influençant pas le fait qu'un mot soit/ne soit pas un palindrome. Si par exemple ton fichier contient "radar\n" alors le mot est un palindrome car le '\n' ne doit pas être pris en compte.

[kerrons]

Le \n est considéré comme séparation entre 2 mots dans le fichier source et le fichier palindrome ne contient pas des \n.

[Matt_Houston]

Je dois faire à peu de choses près cette tête en déchiffrant ton code :



Ton programme souffre des mêmes défauts que celui de ton précédent sujet, que je t'invite à relire en intégralité puisque nos recommandations d'alors s'appliquent également ici.

Oublie fseek. C'est le symptôme le plus patent du caractère inutilement complexe de ton approche. Tu n'as pas réfléchi à ton problème dans sa globalité. Rends-toi compte : tu choisis de relire l'intégralité du fichier de destination afin de déterminer une information dont tu as déjà connaissance, à savoir le nombre de mots identifiés comme palindromes ! C'est ton programme qui a créé et rempli ce fichier de A à Z, tu es donc sensé savoir ce qui s'y trouve !

Reprends ton algo depuis le début, procède par étapes, décompose la résolution du problème en tâches élémentaires.. Fais simple. Retourne faire un tour sur cppreference chercher dans la bibliothèque standard des fonctions de base qui peuvent te servir. Sache que comme précédemment tu peux également faire appel à fscanf qui ne sait pas convertir que des nombres !

[Sve@r]

La prochaine fois tu nous fera un copier/coller de ton fichier qu'on puisse faire la même chose parce qu'avec un tel niveau de flemme, c'est plus un poil mais un dessous de bras que tu as dans la main !!!

Sinon j'ai compris. En dehors de ton indentation de m..., il y a 2 soucis dans ton code

1. tu ouvres ton fichier en "a" donc tu ne peux pas le relire pour compter combien il a de palindromes
2. même ouvert correctement, si tu écris dans le fichier, ta tête de lecture/écriture se trouve en fin de fichier. Tu ne peux donc pas le relire

Accessoirement compter péniblement combien de palindromes se trouvent dans le fichier fait très "usine à gaz" vu que tu pourrais compter directement combien tu en trouves (mais si tu y tiens...). Et puis aère un peu ton code. On dirait que tu payes tes octets quoi...!!!

Code c :

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
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
 
unsigned short nombre(FILE *f) { // retourne le nombre de mots dans un fichier
	int a=0;
	unsigned short i=0;
	long pos=ftell(f);
	fseek(f, 0, SEEK_SET);
	do {
		a=fgetc(f);
		if (isspace(a)) {
			i++;
		}
	} while (a != EOF);
	fseek(f, pos, SEEK_SET);
 
	return i;
}
 
unsigned short palindrome(char ch[]) {//retourne 1 si le mot est palindrome 0 sinon
	int n=strlen(ch);
	for (int i=0; i < (n/2); i++) /* On passera sur ce n/2 qui est calculé à chaque itération... */{
		if (ch[i] != ch[n-i-1]) return 0;
	}
	return 1;
}
 
int main() {
	int c=0;
	FILE *f1=NULL;
	FILE *f2=NULL;
	f1=fopen("mots.txt", "r");
	f2=fopen("palindrome.txt", "a+");
	if (f1 == NULL || f2 == NULL) {
		printf("erreur d'ouverture");
		if (f1) fclose(f1);
		if (f2) fclose(f2);
		return -1;
	}
	do {
		int j=0;
 
		do {  //cette boucle permet de déterminer la longeur de chaqu'un des mots du fichier
			c=fgetc(f1);
			j++;
		} while (isalpha(c));
 
		fseek(f1, -j, SEEK_CUR);//Pour faire retourner le cursor vers le début du mot qui précede le 1er espace ou retour à la ligne rencontré.
		char *T=malloc(j * sizeof (*T));
 
		for (int i=0; i < j; i++) {//mettre le mot trouvé dans un tableau et remettre le cursor à la position avec laquelle il a quitté la boucle do
			T[i]=fgetc(f1);
			printf("T[%d]=%c\n", i, T[i]);
		}
		T[j-1]='\0';
		printf("T=%s\n", T);
 
		if (palindrome(T) != 0) {
			fprintf(f2, "%s ", T);
		}
		free(T);
 
	} while (c != EOF);
	printf("Le nombre des mots palindromes est : %d\n ", nombre(f2));
	fclose(f1);
	fclose(f2);
	return 0;
}

Tu remarqueras que ma fonction nombre() commence par mémoriser la position de la tête de lecture (ftell()) avant de la placer au début du fichier. Puis en final elle la replace à l'endroit intial ce qui laisse donc en sortie le fichier dans le même état qu'à l'entrée.

[kerrons]

Merci pour votre aide j'essayerais d'écrire un autre code plus simple et plus ordonné par contre à part cppreference est ce que pour pouvez me proposer d'autre d'autre sites d’apprentissage du c .

[Matt_Houston]

Il y a de bons cours de C ici-même sur développez. cppreference.com n'est qu'une référence, ça ne t'aidera pas à devenir compétent en C. En revanche tu peux t'y appuyer pour de la documentation sur les fonctionnalités du langage et de la bibliothèque standard, ainsi que des exemples d'usage.

Tu ne t'en sors pas si mal. Ce que tu proposes n'est pas catastrophique. Il te faut persévérer et lire, comprendre, appliquer les recommandations.

Pose-toi les bonnes questions, quel est l'énoncé ? Extraire les palindromes d'une séquence de mots contenue dans un fichier.

• Qu'est-ce qu'un mot ? Comment peut-on le définir formellement ?
• Conséquemment, qu'est-ce qui n'est pas un mot ?
• Comment extraire un tel mot depuis un flux d'entrée (dit « fichier ») ?
• Quelles informations ai-je besoin de stocker à chaque étape du traitement ?
• Etc..

Encore une fois, vas-y par étapes. Essaie de réaliser une version plus simple de ton programme pour commencer, sans allocation dynamique par exemple (donc, qui ne prend en charge que les mots d'une longueur inférieure à une limite établie).

[kerrons]

Merci bien ,je mettrais une autre alternative dés que possible .