La vérification de palindrome chaîne en c

Je suis accepter une chaîne de caractères comme argument de ligne de commande. Je veux vérifier si la saisie de la chaîne est un palindrome ou non et imprimer le résultat. J'ai écrit le code suivant. Mais son afficher le résultat "pas palindrome" pour toutes les entrées.

#include<stdio.h>
#include<string.h>

int main(int argc, char argv[20]) {
    int i;
    int l = strlen(argv);    
    char str[20];
    bzero(str, 20);

    for(i=0; i<l; i++)
    {
        str[i] = argv[i+2];
    } 
    int flag;
    int len = strlen(str);
    for(i=0; i< len/2; i++)
    {
        if(str[i] == str[len - (i+2)])
        {
            flag = 0;
        }
        else
        {
            flag = 1;
            break;
        }
    }

    if(flag == 0)
        printf("Palindrome\n");
    else
        printf("Not a palindrome\n");
}
Je ne suis pas la possibilité de formater le code ici. Quelqu'un peut-il m'aider avec ça aussi avec la programmation de l'enjeu? Comment puis-je imprimer chaque ligne de code sur une ligne différente?
Pour formater votre code, tiret avec quatre espaces, ou utiliser le 101010 bouton. Il n'est pas lisible par la façon dont elle est maintenant.
coller votre code dans la zone de texte à partir de n'importe quel éditeur que vous utilisez, sélectionnez tout, puis de choisir le format de code de touche (il ressemble à peu de 1s et 0s).
Pas de réponse à votre question, mais il n'est pas nécessaire de réinitialiser flag à chaque itération. Initialiser et de ne changer en cas d'échec. Aussi, vous avez le mauvais type de argv qui devrait être char**; ce qui pourrait être la cause de presque n'importe quel genre de ravages.
Merci!!!!! Il a aidé. @Carl Norum: Merci à vous pour votre aide !! @dmckee: Merci à vous !

OriginalL'auteur Khushboo | 2010-08-12

  1. 5

    Vous pourriez le faire dans un K&R-style en ayant deux compenser les itérateurs dans un for-boucle:

    #include <stdio.h>
#include <string.h>
#include <assert.h>

int main(int argc, char *argv[]) {
    assert(argc != 1);

    char *text = argv[1];

    int len = strlen(text);
    int is_palindrome = 1;
    int i, j;

    for(i = 0, j = len - 1; i < len / 2; i++, j--) {
        if(text[i] != text[j]) {
            is_palindrome = 0;
            break;
        }
    }

    printf("%s a palindrome.\n", is_palindrome ? "is" : "isn't");

    return(0);
}

    Changements de original:

    • Modifié(len >> 1) à la division(len /2) tenfour suggéré.
    en fait, je ne suis pas très à l'aise en programmation avec l'utilisation de pointeurs. J'ai besoin de gagner un peu plus d'informations et la compréhension de pointeurs. Peut-être que je vais essayer de programme avec l'utilisation de pointeurs. Est-il un autre moyen que je peux résoudre le palindrome problème?
    optimisation: int len = strlen(text) / 2;
    Je voudrais recommander l'usage de la suce le pointeur de la fun vidéos: cslibrary.stanford.edu/104

    OriginalL'auteur gamen

  2. 2

    Mis à jour en fonction des commentaires:

    int is_palindrome(const char *s)
{
   const char *t = s + strlen(s);
   while (s<t && *s==*--t) s++;
   return s>=t;
}

    Et depuis l'OP veut une version qui n'est pas si lourd sur les pointeurs:

    int is_palindrome(const char *s)
{
   size_t i=0, j = strlen(s);
   while (i<j && s[i]==s[--j]) i++;
   return i>=j;
}

    Pour référence, voici l'original buggy version:

    int is_palindrome(const char *s)
{
   const char *t = s + strlen(s) - 1;
   while (s<t && *s++==*t--);
   return s>=t;
}
    Je ne pense pas que donner "cryptique" C aide à l'apprentissage.
    Je n'appelle pas cela cryptique. J'appelle ça de ne pas faire un repas de choses. Lorsque vous avez une tâche facile à réaliser, ne pas le faire paraître compliqué par écrit tellement...sauf si vous essayez de se laisser aller et de convaincre votre patron que vous avez écrit un tas de "lignes de code".
    Malheureusement, il échoue pour beaucoup de non-palindromes comme "ab". Essayez while (*s == *t && s++ < t--) ;. Et il y a un problème avec la vérification de la chaîne de caractères vide.
    J'ai été en attente pour quelqu'un d'attraper la technicité de la décrémentation de t avant le début de la chaîne lorsque la chaîne est vide. 🙂 Et tu as raison sur l'autre bug - c'est ce que je reçois pour le codage dans une zone de texte sur. Je voudrais le changer pour for (t=s+strlen(s)-1; s<t && *s==*t; s++, t--);
    en fait, je ne suis pas très à l'aise en programmation avec l'utilisation de pointeurs. J'ai besoin de gagner un peu plus d'informations et la compréhension de pointeurs. Peut-être que je vais essayer de programme avec l'utilisation de pointeurs. Est-il un autre moyen que je peux résoudre le palindrome problème?

    OriginalL'auteur R..

  3. 1

    Pour une chose, votre signature pour main est éteint. Il devrait être int main(int argc, char** argv) ou int main(int argc, char * argv[]). Vous traiter un pointeur vers une chaîne de caractères comme s'il s'agissait d'une chaîne de caractères.

    Lorsque vous avez changé, la chaîne que vous voulez doit être en argv[1] (depuis argv[0] est une certaine représentation du nom du programme).

    En fait j'ai essayé avec la main(int argc, char** argv). Mais sa me rendre erreur de casting. Je suis en train de comprendre que c'est trop.
    Ensuite, vous devez comprendre que c'est une erreur, parce que la signature de la principale est mandaté par la norme.
    Je l'ai fait avec argv[1] uniquement. Mais encore sa montrant quelques erreurs et des avertissements.
    Dans ce cas, merci de modifier la question pour montrer votre code révisé et que les erreurs et les avertissements sont.

    OriginalL'auteur David Thornley

  4. 1

    Il ya une bonne affaire pour l'utilisation des pointeurs plutôt que des indices de cette:

    int is_palindrome(const char *s) {
    const char *end = s + strlen(s);
    while (end > s) {
        --end;
        if (*end != *s) return 0;
        ++s;
    }
    return 1;
}

    Si vous aimez le court, le code source de confusion, vous pouvez ré-écrire que:

    int is_palindrome(const char *s) {
    const char *end = s + strlen(s);
    while (end > s) if (*(--end) != *(s++)) return 0;
    return 1;
}

    argv n'est pas une chaîne, c'est un tableau de chaînes, une pour le nom du programme, puis un pour chaque argument (généralement séparées par un espace dans une ligne de commande). Afin de tester si le premier argument est un palindrome, vous êtes intéressé dans argv[1].

    int main(int argc, char **argv) {
    if (argc != 2) {
        printf("usage: %s <string>\n", argv[0]); //or something
        return 1;
    }
    if (is_palindrome(argv[1])) {
        printf("Palindrome\n");
    } else {
        printf("Not a Palindrome\n");
    }
}

    OriginalL'auteur Steve Jessop

  5. 0

    La première boucle n'a pas de sens.
    La copie de la chaîne à l'autre ne fait pas de sens.

    Suffit de le faire et ajuster l'indice:

    #include<stdio.h>
#include<string.h>

int main(int argc, char **argv) {
int i;
char * str = argv[1];
int flag;

int len = strlen(str);

for(i=0; i< (len+1)/2; i++)
{

    printf("DEBUG: Comparing %c %c\n",str[i], str[len - (i+1)]);


    if(str[i] == str[len - (i+1)])
    {
        flag = 0;
    }
    else
    {
        flag = 1;
        break;
    }
}

    if(flag == 0)
    printf("Palindrome\n");
else
    printf("Not a palindrome\n");
}

    OriginalL'auteur LatinSuD

  6. 0

    Pas de pointeurs (à l'exception de l'utilisation pour la fabrication d'une copie de la chaîne d'origine).

    #include    <stdio.h>
#include    <string.h>

int main( int argc, char *argv[] )
{
    char    *s2;

    if ( argc != 2 )
        return ( 1 );   // not properly invoked

    if ( (s2 = strdup( argv[1] )) == NULL )
        return ( 2 );   // failed (not likely)

    printf( "\"%s\" %s a palindrome.\n", argv[1], strcmp( argv[1], strrev( s2 ) ) ? "is not" : "is" );

    free( s2 );

    return ( 0 );
}

    OriginalL'auteur BillP3rd