C中回文函数的意外输出

Question

I've written this function isPalindrome that is meant to take a string input from a separate function, and return 1 if it is a palindrome, and 0 if it is not. The input would be any characters, and may have capitals in it, and the function is meant to sort through these and purely check if it is a palindrome based on the alphabetic characters.

I've been on this for a while and I can't figure out what's going wrong, the whole function is below, but I can't make sense of the output it's giving me, sometimes it completely skips the last else statement, and stops the loop, and I've no idea why. When two non alphabetic characters are entered in a row, the variable a or b does not increment twice, rather it sends it to the last else statement and returns an incorrect value.

I'm trying to write this function without copying any information into separate arrays as well.

int isPalindrome(char s[])
{
int logic;
int a = 0;
int b = 0;
int num = 0;
int count = 0;

while ( s[b]!='\0' )
{
    if ( isalpha(s[b]) != 0 )
    {
        num++;
    }
    b++;
}

b = b - 1;

printf("The number of characters is: %d\n", b);
printf("The number of alpha characters is: %d\n", num);

while ( count < num/2 )
{

    if ( !isalpha(s[a]) || s[a] == ' ')
    {
        a++;
    }
    else
    {
        count++;
    }
    if ( !isalpha(s[b]) || s[b] == ' ')
    {
        b--;
    }

    if ( toupper(s[a]) == toupper(s[b]) )
    {

        printf("s[%d]: %c | s[%d]: %c\n", a, toupper(s[a]), b, toupper(s[b]));

        a++;
        b--;

        if ( a == b )
        {
            logic = 1;
        }
    }
    else
    {
        logic = 0;
        break;
    }
}

   return logic;
}

Answer 1

There are multiple errors (1) logic must be initialized to 1 (2) Only one invalid char is checked per iteration of loop.

If you remove the following code, it should work (I mean without valid char checking).

if ( !isalpha(s[a]) || s[a] == ' ')
{
    a++;
}
else
{
    count++;
}
if ( !isalpha(s[b]) || s[b] == ' ')
{
    b--;
}

For removing invalid characters, better do this before entering the loop or check for 'a < b' instead of count/2 and continue on invalid char as below.

logic=1;
while (a<b)
{
    if ( !isalpha(s[a]))
    {
        a++;
        continue;
    }

    if ( !isalpha(s[b]))
    {
        b--;
        continue;
    }

    if ( toupper(s[a]) == toupper(s[b]) )
    {
        printf("s[%d]: %c | s[%d]: %c\n", a, toupper(s[a]), b, toupper(s[b]));

        a++;
        b--;
    }
    else
    {
        logic = 0;
        break;
    }
}

 return logic;

Answer 2

It seems you want your palindrome tester to only consider alphabetical characters, and disregard case. If that is the case, the logic of your program is wrong.

You have a and b as the indices of your string, where a starts from the beginning and b starts from the end. Instead of computing the number of tests you have to do, I think it is better to just set b to the end, and start your work loop. The loop continues so long as a < b is true:

int a = 0;
int b = strlen(s) - 1;

while (a < b)
{

In side of your loop, you should increment a if s[a] is not a letter, and decrement b if s[b] is not a letter, so long as a continues to be less than b .

    while (a < b && !isalpha(s[a]))
    {
        ++a;
    }
    while (a < b && !isalpha(s[b]))
    {
        --b;
    }

If after the adjustments, a is is still less than b , then we can compare s[a] and s[b] , disregarding case. If they are not equal, then the string is not a palindrome, so we can break from the loop. Otherwise, a is incremented, b is decremented, and the loop continues back to the top:

    if (a < b &&  toupper(s[a]) != toupper(s[b]))
    {
        break;
    }
    ++a;
    --b;
}

If the loop ends and a < b is still true, it means that toupper(s[a]) != toupper(s[b]) , so the string is not a palindrome, and we can return false. Otherwise, it is a palindrome. So the function can return that fact:

if (a < b)
{
    return false;
}
else
{
    return true;
}
// or more succinctly: return !(a < b);

Answer 3

Your error is in the code that leads to the "payload" palindrome condition check:

if ( toupper(s[a]) == toupper(s[b]) )

The code before that check is supposed to bring a and b in such a state that both s[a] and s[b] are letters.

Your code does not do that: specifically, sequences of multiple non-alphabetic characters would bring you to a state when you compare a letter to a non-letter, or even two non-letters.

A simpler way of dealing with this problem would be splitting your program into two stages. The first stage would eliminate all non-letters from the input string; the second stage would perform the palindrome check.

Make a copy of the incoming string, then go through it character-by-character, copying only letters back into the string. You would end up with a string that is either shorter or the same length as the original.

Now palindrome check becomes trivial: start from both ends, and check for equality of toupper until the two ends meet in the middle. Don't forget to free the copy of your string!

Answer 4

Your code to skip over non-alpha characters doesn't handle the case of multiple consecutive non-alpha characters. You know from the preprocessing pass how many alphabetic characters there are, so you need to replace your if statements by while loops, and make the body of the else unconditional.

There are a number of other simplifications in the code that I'd make automatically.

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

static
int isPalindrome(char s[])
{
    int a = 0;
    int b = 0;
    int num = 0;
    int count = 0;

    while (s[b] != '\0')
    {
        if (isalpha(s[b++]))
            num++;
    }

    printf("The number of characters is: %d\n", b);
    printf("The number of alpha characters is: %d\n", num);

    while (count < num/2)
    {
        count++;
        while (!isalpha(s[a]))
            a++;
        while (!isalpha(s[b]))
            b--;

        if (toupper(s[a]) != toupper(s[b]))
            return 0;
        printf("s[%d]: %c | s[%d]: %c\n", a, toupper(s[a]), b, toupper(s[b]));
        a++;
        b--;
    }

    return 1;
}

int main(void)
{
    char line[256];
    while (fgets(line, sizeof(line), stdin) != 0)
    {
        line[strlen(line)-1] = '\0';
        printf("Input: <<%s>>\n", line);
        if (isPalindrome(line))
            puts("Palindrome");
        else
            puts("Not a palindrome");
    }
    return 0;
}

This works for perverse sequences of alphabetic and non-alphabetic characters. It treats an empty line and a line consisting of all non-alphabetic characters as palindromes; if you want them to be rejected, you could treat that by reporting 'not a palindrome' when the number of alphabetic characters is zero after the loop that counts the number of alphabetic characters. The code does an early return when it detects that the string cannot be a palindrome. You might move the print statement in the loop before the test; then you get to see the results of each comparison, not just the comparisons that succeed.