Python palindrome program not working

Question

I've written a simple program in python which checks if the sentence is palindrome. But I can't figure out why isn't it working. The results is always False. Does anyone knows what's wrong?

def isPalindrome(word):
    # Removes all spaces, and lowercase the word.
    word = word.strip().lower()
    word = word.replace(" ", "")

    # If the length of the word is less than 1, means its a palindrome
    if (len(word) <= 1):
        return True

    # Compares the first and the last character of the word.
    # If it is the same, calls the function again with the same word,
    # without its first and last characters. If its not the same, its
    # not palindrome
    else:
        if word[0] == word[-1]:
            isPalindrome(word[1:-1])
        else:
            return False


sentence = input("Enter a sentence: \n")

if (isPalindrome(sentence)):
    print("The sentence %s is palindrome." % sentence)
else:
    print("The sentence %s is NOT palindrome" % sentence)

Answer 1

You're making this way more complicated than it has to be:

def palindrome(sentence):
    sentence = sentence.strip().lower().replace(" ", "")
    return sentence == sentence[::-1]

sentence[::-1] uses string slicing to reverse the characters in the string.

A slightly more verbose solution that shows how the logic of the return statement above works:

def palindrome(sentence):
    sentence = sentence.strip().lower().replace(" ", "")
    if sentence == sentence[::-1]:
        return True
    else:
        return False

Answer 2

You aren't returning the result of the function.

replace :

if word[0] == word[-1]:
    isPalindrome(word[1:-1])

with

if word[0] == word[-1]:
    return isPalindrome(word[1:-1])

Answer 3

You algorithm is fine, the only problem is that you don't return the true result through the recursion, you have to return the isPalindrome result when calling it recursively:

else:
    if word[0] == word[-1]:
        return isPalindrome(word[1:-1]) #this changed
    else:
        return False

Answer 4

The best way to check a word is palindrome or not in Python is as below:

var[::] == var[::-1]

But, it is very important to understand that Python creates a new copy of string when you do var[::-1] Python internally don't know if the reverse will result in same string or not. So, it's coded in a way where it creates a new copy of it. So, when you try var[::1] is var[::-1] you will get FALSE.

For example:

var = "RADAR" var1 = var[::] var is var1 True var2 = var[0:6:1] var is var2 True var3 = var[::-1] var is var3 False var4 = var[-1:-6:-1] var is var4 False var1 'RADAR' var2 'RADAR' var3 'RADAR' var4 'RADAR'

Here you can see when you move forward, it doesn't creates the copy of "RADAR", it uses the same reference. Because PY internally understand this operation will result in same string object. But, when you move in backward direction, the result can be different. For example, if I do the same operation for "Ethans", then the reverse of it will not be same. So, PY is not aware what will be the result of reversed string and it creates the new copy of it.

Therefore, reversed string is returning false value with 'is' operator.

One more interesting point to note here. See below example:

var = "abc" var1 = "abc" var is var1 True var = "Ethans Baner Pune" var1 = "Ethans Baner Pune" var is var1 False

We know string is immutable and follows Singleton DP, then why the second case is returning FALSE??

This is because PY don't want to compromise on SPEED and PERFORMANCE. If you write a very long string and it's already present in memory, PY should refer to same string. But, finding that long string will take very long time and performance will be decreased. So, rather than referring to existing string, PY instead create a new one. We have also understood this for integers, where it only follow Singleton DP approach till limited value(256).

Let's see one more example:

var = "abcdefgh" var1 = "abcdefgh" var is var1 True var = "abcd efgh" var1 = "abcd efgh" var is var1 False

Answer 5

You need to replace "input" with "raw_input". Also, you are calling isPalindrome recursively and there is a mistake here as well. It should be:

if word[0] == word[-1]:
    return isPalindrome(word[1:-1])
else:
    return False

Check the corrected code below:

def isPalindrome(word):
    # Removes all spaces, and lowercase the word.
    word = word.strip().lower()
    word = word.replace(" ", "")

    # If the length of the word is less than 1, means its a palindrome
    if (len(word) <= 1):
        return True

# Compares the first and the last character of the word.
# If it is the same, calls the function again with the same word, without its first and last characters.
# If its not the same, its not palindrome
    if word[0] == word[-1]:
        return isPalindrome(word[1:-1])
    else:
        return False


sentence = raw_input("Enter a sentence: \n")

if (isPalindrome(sentence)):
    print("The sentence %s is palindrome." % sentence)
else:
    print("The sentence %s is NOT palindrome" % sentence)

Answer 6

I presume this is an assignment and the recursion is necessary, obviously return word == word[::-1] is simpler but is not really relevant. You can write your recursive function a bit more succinctly:

def isPalindrome(word):
    if not word:
        return True
    return word[0] == word[-1] and isPalindrome(word[1:-1])

word[0] == word[-1] will either be True or False so you will either reach an empty string where not word will True so the recursion ends and the function returns True or word[0] == word[-1] will be False so the function will return False as and isPalindrome(word[1:-1]) will never be evaluated.

I would also maybe do the lowering outside of the function:

def isPalindrome(word):
    if not word:
        return True
    return word[0] == word[-1] and isPalindrome(word[1:-1])


sentence = input("Enter a sentence: \n")
sentence = sentence.strip().lower()
sentence = sentence.replace(" ", "")
if isPalindrome(sentence):
    print("The sentence %s is palindrome." % sentence)
else:
    print("The sentence %s is NOT palindrome" % sentence)

Answer 7

Since the mistake is already explained and the obvious s == s[::-1] is already taken, I'll just throw a possibly minimal version of the original into the mix:

def isPalindrome(s):
    s = s.strip().lower()
    return not s or s[0] == s[-1] and isPalindrome(s[1:-1])

Note that you don't need replace(" ", ""). Space on the outside is removed with strip() now, and spaces on the inside will be removed by the strip() later, in a call deeper into the recursion (if we don't stop earlier because a s[0] == s[-1] fails).