Palindrome

Version imprimable

14/10/2004, 13h20
zouyou

Palindrome

Bonjour,

j'ai un probleme :oops: :oops: :oops:

j'essaye de mettre en place une fonction qui renvoie '' Palindrome" si on introduit un mot palindrome et " Pas palindrome dans le cas contraire.

j'avoue que tout ce que j'ai fait me parait logique mais ça marche pas pour tout le temps par esemple avec la phrase : elu par cette crapule.

Merci d'avance :wink: :wink: :wink:
14/10/2004, 13h21
Luc Hermitte

Et si tu nous montrais ce que tu as fais ?

Palindrome

Exusez moi, j'ai oublié d'ajouter le code,

Code:

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
// Fonction qui vérifie si un Mot est un Palindrome ou non.
 
#include <iostream>
#include <string>
using namespace std;
 
bool unpalindrome (string T);
 
void main ()
 
{
 
	string mot;
 
	cout <<"saisir le mot \n";
	cin >>mot;
 
	if (unpalindrome (mot))
		cout <<"Palindrome!\n";
 
	else 
		cout <<" Pas Palindrome!\n";
}
 
 
bool unpalindrome (string T) // Notre Fonction
{
	int i=0, j=0;
 
	while (T[j]!='\0') j++;
 
	j--;
 
 
	while (i<j && T[i]==T[j])
	{
 
		i++;
		j--;
 
		if (T[i]==' ') i++;
 
		else continue;
 
		if (T[j]==' ') j--;
 
		else continue;
 
	}
 
   	if (T[i]==T[j]) return true;
 
    else return false;
}

[Balises code rajoutées, posts intermediaires supprimés et topic fusionné... ouf :D. Aucun problème, mais merci d'y penser à l'avenir :wink:]

14/10/2004, 14h10
Laurent Gomila

Salut,

Je n'ai pas vu d'où venait l'erreur, mais je peux déjà te donner quelques conseils :

- La taille d'un string s'obtient avec chaine.size().
- Tu peux parcourir ta chaine à l'aide d'iterator (à l'endroit) et de reverse_iterator (à l'envers).
- Mieux vaut passer ton string à la fonction par référence constante, tu éviteras une recopie inutile.
14/10/2004, 14h20
jab

Dans ton exepmle il n'est pas palindrome car tu traite les espaces comme un caractère donc e=e,l=l,u=u mais ( )!=a

Ok, en fait lorsque tu tapes une chaine au clavier, l'espace sera compté comme séparateur et donc si tu rentres "elu par cette crapule", seul "elu" sera dans ta chaine et envoyé à la fonction, ce qui n'est donc pas un palindrome. Utilise std::getline() pour saisir des chaines avec espaces.

Sinon, voici une version moins lourde (à écrire) qui utilise les facilités du C++ :
Code:

1 2 3 4 5 6 7 8 bool unpalindrome (string T) // Notre Fonction { // On supprime les espaces T.erase(std::remove(T.begin(), T.end(), ' '), T.end()); // On compare avec la chaîne inverse return std::string(T.rbegin(), T.rend()) == T; }
En plus, ta fonction était incorrecte car un std::string n'est pas forcément terminé par un '\0' ; et puis ta manière de sauter les espaces ne me paraît pas correcte non plus, a priori.

14/10/2004, 15h45
Aurelien.Regat-Barrel

Si tu veux tester :
http://www.norvig.com/pal2txt.html
:lol:

A part les problèmes signalés par les spécialistes C++, tu as un bug dans l'algo :
Pour ne pas tenir compte des espaces tu dois faire:

Code:

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
bool unpalindrome (char * T) // Notre Fonction
{
   int i=0, j=0;
 
   while (T[j]!='\0') j++;
 
   j--;
 
 
   while (i<j && T[i]==T[j])
   {
 
      i++;
      j--;
 
      if (T[i]==' ') i++;
 
       if (T[j]==' ') j--;
   }
 
   if (T[i]==T[j]) 
        return true;
   else 
         return false;
}

PS perso : ce qui m'ennuie dans les solutions C++, c'est qu'on laisse le soin à la machine de résoudre les problèmes qu'on ne sait pas résoudre soi-même :

Citation:

Envoyé par Loulou24

Code:

1
2
3
4
5
6
7
8
bool unpalindrome (string T) // Notre Fonction 
{ 
    // On supprime les espaces 
    T.erase(std::remove(T.begin(), T.end(), ' '), T.end()); 
 
    // On compare avec la chaîne inverse 
    return std::string(T.rbegin(), T.rend()) == T; 
}

Pas bon si tu as des espaces en début ou fin.

(Quitte à faire du C -> :s/char \*/const char */)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
bool est_pal(const char * b) 
{
    const char * e = b + strlen(b);
    while (b < e)
    {
         if      (isspace(*b)) ++b;
         else if (isspace(*e)) --e;
         else if (*b == *e) { ++b; --e;}
         else return false;
    }
    return true;
}

(non optimal)

14/10/2004, 17h10
Trap D

Ca c'est du C :lol:
Sauf qu'il faut faire

Code:

const char * e = b + strlen(b)-1;
14/10/2004, 17h40
Luc Hermitte

Tout à fait. Au temps pour moi. :oops:
14/10/2004, 18h37
zouyou

Palindrome

Merci beaucoup pour vous tous, vous m'avez apporté beaucoup de choses.

Trap D, j'aimerais vous dire que j'ai corrigé le code comme vous me l'avez dit et ça marche encore pas .

Ben si, chez moi il fonctionne parfaitement.
Testé avec

Code:

1
2
3
4
5
6
7
8
9
10
11
12
   char *mot= "elu par cette crapule";
   char *mot1= "even in eden i win eden in eve";
   if (unpalindrome (mot))
      printf("%s : Palindrome!\n", mot);
 
   else
      printf("%s : Pas Palindrome!\n", mot);
 
   if (unpalindrome (mot1))
      printf("%s : Palindrome!\n", mot1);
   else
      printf("%s : Pas Palindrome!\n", mot1);

Mea culpa :oops:
Effectivement, en y réfléchissant un peu plus, la fonction était buguée à cause des suites d'espaces qui n'y étaient pas traitées. je propose donc cette solution qui garde le même esprit :

Code:

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
bool unpalindrome (char * T) 
{
   int i=0, j=0;
 
   while (T[j]!='\0') j++;
 
 
 
   i = -1;
   do 
   {
 
      i++;
      j--;
 
      while (!isalpha(T[i])) i++;
 
      //else continue;
 
      while (j >= 0 && !isalpha(T[j])) j--;
 
      //else continue;
 
   }
   while (i<j && T[i]==T[j]);
 
   if (T[i]==T[j]) return true;
 
    else return false;
}

15/10/2004, 00h17
Luc Hermitte

Autant tester j>i plutôt que 0, non ?

Sinon, c'est un débutant, pitié ne les entretenez pas dans "si (cond == V) retourner vrai sinon retourner faux". On a "retourner cond" qui est très très bien!!!
08/05/2005, 17h20
NeHuS

salut on va voir si il y a des joueurs :
en recusrsif ça donnerait quoi le palyndrome ? :lol:

Citation:

salut on va voir si il y a des joueurs

Toujours partant :D

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
bool Palindrome_(const char* It1, const char* It2)
{
    while (*It1 == ' ')
        ++It1;
 
    while (*It2 == ' ')
        --It2;
 
    if (It1 > It2)
        return true;
    else if (*It1 != *It2)
        return false;
    else
        return Palindrome_(It1 + 1, It2 - 1);
}
 
bool Palindrome(const char* Mot)
{
    return Palindrome_(Mot, Mot + strlen(Mot) - 1);
}

En C pour ne faire râler personne, mais marche également en remplaçant const char* par std::string::const_iterator.

Et pourquoi pas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
bool Palindrom (const string s)
{
     stack<char> ss;
     for(int i = 0;i<s.length();i++)
            ss.push(s[i]);
 
    for(int i =0,i<s.lenght();i++)
   {
         if(ss.top()!=s[i]) return false;
         else sss.pop();
    }
return true;
}

Bon c'est à essayer :arrow:

dans le méme sujet

Moi aussi j'ai un mini projet informatique pour la réalisation d'un programme intitulé palindrome :cry: .
IL est éxécutable mais il ne m'affiche pas toute la liste des palindromes :cry:

Sujet du programme :

La réalisation d’un programme en c qui établie les fonctions suivantes :
*Le parcour d’un fichier qui existe déjà dans un répertoire sur notre PC.
*La recherche de tous les palindromes qui existe dans ce fichier.
*La création d’une liste chainee qui va contenir tous les palindromes.
*Chaque élément de cette liste contient le palindrome, le nombre d’occurrences de chaque palindrome sur chaque ligne en forme de tableau.
*Le teste si le palindrome qu’on a trouvé existe déjà dans la liste ou pas
Si oui on va juste incrémenter le nombre d’occurrences de ce palindrome
Si non on va ajouter le palindrome dans notre liste .

UN plus dans le programme :

La création d’une interface graphique avec la bibliothèque SDL sur le programme dev c .
voila mon code

Code:

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
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <stdlib.h>
 
/*Definition de la liste */
 
      typedef struct pall
      {
              char chaine[30];
              int t[100];
              struct pall  *prev;
              struct pall  *next;
              }
      Pall;
 
 
      typedef struct 
              {
                      Pall *first;
                      Pall *last;        
                      int  Nbre ;
                      }
      liste_Pall;
 
 
       /*Initialisation de la liste */
 
        liste_Pall *initialiser_liste()
         {liste_Pall *L;
                   printf("Intialisation de la liste chainee \n");
                    L = (liste_Pall *) malloc (sizeof(liste_Pall));
                    L->first=NULL;
                    L->last=NULL;
                    L->Nbre=0;
 
                    return(L);
 
         }  
 
/* Procedure creation fichier */
void Creer(FILE **fp)
{
char f[30];
printf("Fichier:");
scanf("%s",f);
*fp=fopen(f,"r") ;
 
if (*fp==NULL )
{printf("Probleme ouverture!!!");exit(EXIT_FAILURE); }
 
}
/* fonction palindrome */
int palindrome (char *s)
{int k,j,l;
l=strlen(s);
 
for(k=0,j=l-1;k<j;k++,j--)
{if(s[k]!=s[j])
return 0;}
return 1;
 
}        
 
  /* recherche un palindrome dans la liste */
 
 Pall* Rechercher(char s[30],liste_Pall *L)
 {     Pall *p ;
 
        p=L->first;
        while(p!= NULL && strcmp(p->chaine,s)!=0)
        {p = p->next;printf("%s",p->chaine);}
 
        return p;
 } 
 
 
/*Ajouter le palindrome dans la liste */
   liste_Pall * Ajout_Pall (liste_Pall *l ,char s[30] ,int ligne)
   {int i;
   Pall *nouv = (Pall *)malloc(sizeof(Pall));
 
   if(!nouv) exit(EXIT_FAILURE);
  for(i=1;i<=100;i++) 
  {nouv->t[i] =0;}
 strcpy(nouv->chaine,s);
 nouv->t[ligne] = 1;
   if (l->Nbre==0)
{   nouv->next = NULL;
    nouv->prev = NULL;
    l->last = nouv;
    l->first = nouv;
    l->Nbre++;
}
else
{
   nouv->prev = l->first;
   nouv->next = NULL; 
   l->first=nouv;
   l->Nbre++;
}
 return(l);  }
 
 /* Affichage de la liste de palindrome */
 
 
 void affiche(liste_Pall *L)
{ 
  Pall *courant;
 
  courant = L->first; /* point du départ le 1er élément */
  printf("les mots palaindrome dans la liste sont :\n ");
 
  while(courant != NULL)
  {
    printf("%s\n",courant->chaine);
    courant = courant->next;
  }
 
}
 
 
int  main()
{
    FILE  *fp=NULL;
    char s[30];
 
 
int i,p;
int c;
Pall *q;liste_Pall *L;
Creer(&fp) ;
i=1;
L=initialiser_liste();
 
while((c=fgetc(fp))!=EOF)
{  
      if (c == '\n') {i=i+1;}
 
      fscanf(fp,"%s",s);
 
      p=palindrome(s);
 
 
      /* Affichage du résultat */
      if(p==1)
      { 
      printf("Le mot %s est palindrome ",s);
      q=Rechercher(s,L);
      if (q==NULL)
      {   printf("n'existe pas dans la liste on va l'ajouter\n");
          L=Ajout_Pall (L,s,i);
      }
      else
      {printf("existe  :%d fois  \n",q->t[i]+1);}
 
      }
 
}
affiche(L);
getch();
fclose(fp);
return(0);
 
}