Determine if a character string is palindromic

[lovecreatesbeauty]

Hello experts,

I write a function named palindrome to determine if a character string
is palindromic, and test it with some example strings. Is it suitable
to add it to a company/project library as a small tool function
according to its quality? I will be very happy to get your suggestion
from every aspect on it: interface design, C language knowledge or
algorithm efficient.

Sincerely,

lovecreatesbeau ty
/* Filename : palindrome.c
* Function : bool palindrome(char *s);
* Description: to determine if a character string is palindromic
* Date : 8 May 2006
*/

#include <stdbool.h>
#include <stddef.h>
#include <string.h>

bool palindrome(char *s)
{
bool palindromic = true;
size_t len = strlen(s);

if (len > 1)
{
for (unsigned i = 0; i < len / 2; ++i)
{
if (s[i] != s[len - 1 - i])
{
palindromic = false;
break;
}
}
}

return palindromic;
}
/* test */
#include <stdio.h>

int main()
{
printf("%i\n", palindrome("dee d"));
printf("%i\n", palindrome("dee ds"));
}

/*
$ gcc -W -Wall -std=c99 -pedantic palindrome.c
$ ./a.out
1
0
$
*/

[Richard Heathfield]

lovecreatesbeau ty said:

Hello experts,

I write a function named palindrome to determine if a character string
is palindromic, and test it with some example strings. Is it suitable
to add it to a company/project library as a small tool function
according to its quality? I will be very happy to get your suggestion
from every aspect on it: interface design, C language knowledge or
algorithm efficient.

You might want to test it with these well-known palindromes:

"Madam, I'm Adam!"
"Able was I, ere I saw Elba."
"A man, a plan, a canal - Panama!"

Does it correctly identify them as palindromes?

(By the way, that question was rhetorical.)

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[Vladimir Oka]

lovecreatesbeau ty opined:

Hello experts,

I write a function named palindrome to determine if a character
string is palindromic, and test it with some example strings. Is it
suitable to add it to a company/project library as a small tool
function according to its quality? I will be very happy to get your
suggestion from every aspect on it: interface design, C language
knowledge or algorithm efficient.

Sincerely,

lovecreatesbeau ty
/* Filename : palindrome.c
* Function : bool palindrome(char *s);
* Description: to determine if a character string is palindromic
* Date : 8 May 2006
*/

#include <stdbool.h>
#include <stddef.h>
#include <string.h>

bool palindrome(char *s)
{
bool palindromic = true;
size_t len = strlen(s);

if (len > 1)
{
for (unsigned i = 0; i < len / 2; ++i)
{
if (s[i] != s[len - 1 - i])
{
palindromic = false;
break;
}
}
}

return palindromic;
}
/* test */
#include <stdio.h>

int main()
{
printf("%i\n", palindrome("dee d"));
printf("%i\n", palindrome("dee ds"));
}

/*
$ gcc -W -Wall -std=c99 -pedantic palindrome.c
$ ./a.out
1
0
$
*/

Apart from the fact that it doesn't work, it looks fairly good.
Did you consider upper/lower case? Try: "Ana voli Milovana".
Or, alternatively, you need to define "palindrome " more precisely.

--
Microsoft is not the answer.
Microsoft is the question.
NO (or Linux) is the answer.
(Taken from a .signature from someone from the UK, source unknown)

<http://clc-wiki.net/wiki/Introduction_to _comp.lang.c>

[Robert Gamble]

lovecreatesbeau ty wrote:

Hello experts,

I write a function named palindrome to determine if a character string
is palindromic, and test it with some example strings. Is it suitable
to add it to a company/project library as a small tool function
according to its quality? I will be very happy to get your suggestion
from every aspect on it: interface design, C language knowledge or
algorithm efficient.

Sincerely,

lovecreatesbeau ty
/* Filename : palindrome.c
* Function : bool palindrome(char *s);
* Description: to determine if a character string is palindromic
* Date : 8 May 2006
*/

#include <stdbool.h>
I am not a fan of stdbool.h but that's just me.
#include <stddef.h>
#include <string.h>

bool palindrome(char *s)
If the function does not modify the string pointed to by s (and it
doesn't, I looked ahead), it would be better to indicate this:

bool palindrome (const char *s)
{
bool palindromic = true;
size_t len = strlen(s);

if (len > 1)
{
for (unsigned i = 0; i < len / 2; ++i)
What happens if len/2 > UINT_MAX but less than SIZE_MAX?
I would declare i as size_t.
{
if (s[i] != s[len - 1 - i])
{
palindromic = false;
That's quite a narrow definition of palindrome you have there. A
generally well-accepted definition of palindrome from wikipedia states:

"A palindrome is a word, phrase, number or other sequence of units
(such as a strand of DNA) that has the property of reading the same in
either direction (the adjustment of punctuation and spaces between
words is generally permitted)"

Your example does not allow things like:
"Aba"
"A, A"
which most people would consider to be palindromic.
break;
}
}
}

return palindromic;
}

Below is my version of the function, the main difference is the fact
that it is much less strict than yours ignoring all non-alphanumeric
characters:

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

int palindrome(cons t char *s)
{
size_t len = strlen(s);
const char *left, *right;

if (len > 1) {
left = s; right = s+(len-1);
while (left < right) {
if (!isalnum(*left )) {
left++;
continue;
}
if (!isalnum(*righ t)) {
right--;
continue;
}
if (toupper(*left) == toupper(*right) ) {
left++, right--;
continue;
} else {
return 1;
}
}
}
return 0;
}

/* test */
#include <stdio.h>
#define BUF_SIZE 80

int main(void)
{
char buf[BUF_SIZE];
while (fgets(buf, 80, stdin) != NULL)
palindrome(buf) ? puts("Palindrom e") : puts("Not a palindrome");
return 0;
}

Robert Gamble

[Robert Gamble]

Robert Gamble wrote:

Below is my version of the function, the main difference is the fact
that it is much less strict than yours ignoring all non-alphanumeric
characters:

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

int palindrome(cons t char *s)
{
size_t len = strlen(s);
const char *left, *right;

if (len > 1) {
left = s; right = s+(len-1);
while (left < right) {
if (!isalnum(*left )) {
left++;
continue;
}
if (!isalnum(*righ t)) {
right--;
continue;
}
if (toupper(*left) == toupper(*right) ) {
left++, right--;
continue;
} else {
return 1;
That should be return 0;
}
}
}
return 0;

And that should be return 1;

Robert Gamble

[CBFalconer]

lovecreatesbeau ty wrote:

I write a function named palindrome to determine if a character string
is palindromic, and test it with some example strings. Is it suitable
to add it to a company/project library as a small tool function
according to its quality? I will be very happy to get your suggestion
from every aspect on it: interface design, C language knowledge or
algorithm efficient.

Sincerely,

lovecreatesbeau ty

/* Filename : palindrome.c
* Function : bool palindrome(char *s);
* Description: to determine if a character string is palindromic
* Date : 8 May 2006
*/

.... snip code ...

I think you will find the following somewhat simpler. It doesn't
need the C99 stdbool.h include, and guarantees not to modify the
input string. It also handles the silly cases.

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

/* Returns 1 for palindrome, 0 for non-palindrome */
/* ispalindrome is a reserved function name */
int qpalindrome(con st char *s)
{
const char *p;

/* null and empty strings are not palindromes */
if (s && *s) {
p = s + strlen(s) - 1;
while (p > s)
if (*p-- != *s++) return 0;
return 1;
}
return 0;
} /* qpalindrome */

/* It is left as an exercise to allow mixed case. */
/* or to elide blanks */

void check(const char *s)
{
if (s) printf("\"%s\" ", s);
if (qpalindrome(s) ) puts("is");
else puts("isn't");
} /* check */

int main(void)
{
puts("Checking palindromes");
check("noon");
check("Noon");
check("dad");
check("Dad");
check(NULL);
check("");
return 0;
} /* main */

--
"If you want to post a followup via groups.google.c om, don't use
the broken "Reply" link at the bottom of the article. Click on
"show options" at the top of the article, then click on the
"Reply" at the bottom of the article headers." - Keith Thompson
More details at: <http://cfaj.freeshell. org/google/>
Also see <http://www.safalra.com/special/googlegroupsrep ly/>

[john]

Robert Gamble wrote:

Robert Gamble wrote:

return 1;

That should be return 0;

}
}
}
return 0;

And that should be return 1;

Is there any particular reason that functions often behave this way?
If they succeed, they return 0, which in C is false, and vice versa.

Hmm, while I was writing this it occurred to me that it can have
something to do with error reporting. Different return values can
indicate different errors. Is that the reason?

[Vladimir Oka]

john opined:

Robert Gamble wrote:

Robert Gamble wrote:

return 1;

That should be return 0;

}
}
}
return 0;

And that should be return 1;

Is there any particular reason that functions often behave this way?
If they succeed, they return 0, which in C is false, and vice versa.

Hmm, while I was writing this it occurred to me that it can have
something to do with error reporting. Different return values can
indicate different errors. Is that the reason?

Probably because returning 0 from `main()` is an indication of
successful program termination.

--
"Besides, I think [Slackware] sounds better than 'Microsoft,' don't
you?"
(By Patrick Volkerding)

<http://clc-wiki.net/wiki/Introduction_to _comp.lang.c>

[Keith Thompson]

"lovecreatesbea uty" <lo************ ***@gmail.com> writes:

I write a function named palindrome to determine if a character string
is palindromic, and test it with some example strings. Is it suitable
to add it to a company/project library as a small tool function
according to its quality? I will be very happy to get your suggestion
from every aspect on it: interface design, C language knowledge or
algorithm efficient.

/* Filename : palindrome.c
* Function : bool palindrome(char *s);
* Description: to determine if a character string is palindromic
* Date : 8 May 2006
*/

#include <stdbool.h>
#include <stddef.h>
#include <string.h>

bool palindrome(char *s)
{
bool palindromic = true;
size_t len = strlen(s);

if (len > 1)
{
for (unsigned i = 0; i < len / 2; ++i)
{
if (s[i] != s[len - 1 - i])
{
palindromic = false;
break;
}
}
}

return palindromic;
}
/* test */
#include <stdio.h>

int main()
{
printf("%i\n", palindrome("dee d"));
printf("%i\n", palindrome("dee ds"));
}

Your use of <stdbool.h> and of a declaration within a for loop mean
your program will work only with a C99 implementation, or with an
implementation that provides these features as an extension. Only you
can decide whether that's a problem. Converting the program to C90,
or rather to the common subset of C90 and C99, is straightforward .

You use an unsigned object to iterate through the string, but the
upper bound of the iteration is of type size_t. It's conceivable that
size_t could be bigger than unsigned, and that your loop could fail
for a very long string. You're unlikely to run into this problem
either in practice or in testing, unless you're specifically looking
for it. On many implementations , you'll never see a problem (i.e.,
testing can never reveal the bug). In other words, this bug is
particularly insidious.

The printf statements invoke undefined behavior. Your palindrome()
function returns a bool; printf's "%i" expects an int.

Note that "%i" is equivalent to "%d" in a printf format string; "%d"
is much more common in my experience. Using "%i" is perfectly correct
(if the corresponding argument is an int), but seeing it forces me to
pause and wonder why the author chose to use "%i" rather than "%d".
Perhaps the author thought there was a difference, and is failing to
express something significant. This is a minor style issue; feel free
to ignore it. (Note that "%d" and "%i" do behave differently in
scanf.)

You haven't defined the term "palindromi c". The usual definition
ignores whitespace, punctuation, and the distinction between upper and
lower case; for example, "A man, a plan, a canal, Panama!" is
considered to be a palindrome. If you want to use a simpler
definition, that's fine, but you need to state clearly what definition
you're using.

Finally, the only use I've ever seen for a function to determine
whether a string is a palindrome is as an exercise in a programming
class or other tutorial. I can't imagine including such a function,
however well implemented, in a library, or calling it other than in a
test of the function itself.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Ben C]

On 2006-05-08, john <[e-mail] > wrote:

Robert Gamble wrote:

Robert Gamble wrote:

return 1;

That should be return 0;

}
}
}
return 0;

And that should be return 1;

Is there any particular reason that functions often behave this way?
If they succeed, they return 0, which in C is false, and vice versa.

Hmm, while I was writing this it occurred to me that it can have
something to do with error reporting. Different return values can
indicate different errors. Is that the reason?

I always assumed that was the basic reason. Occasionally people write
functions that return boolean "true for success", and often functions
that return pointers return NULL for failure, so you always have to be a
bit careful with

if (f())
/* succeeded or failed? */

etc.