# Palindrome strings

A palindrome is a word, phrase, number, or other sequence of characters which reads the same backward or forward. This includes capital letters, punctuation, and word dividers.

Implement a function that checks if something is a palindrome.

## Examples
```
isPalindrome("anna")   ==> true
isPalindrome("walter") ==> false
isPalindrome(12321)    ==> true
isPalindrome(123456)   ==> false
```

Difficulty: introductory

Starter code:

def is_palindrome(string):
	

Solutions:
def is_palindrome(string):
    return str(string)[::-1] == str(string)

def is_palindrome(string):
    return str(string).lower() == str(string).lower()[::-1]

def is_palindrome(string):
    return str(string) == str(string)[::-1]

def is_palindrome(string):
    string=str(string)
    return string==string[::-1]

def is_palindrome(string):
    a = []
    for i in str(string):
        a.insert(0, i)
    if list(str(string)) != a:
        return False
    else:
        return True


def is_palindrome(string):
    string = str(string)
    return True if string[:len(string)//2] in string[len(string)//2:][::-1] else False

def is_palindrome(string):
    string = str(string)
    return (string[::-1] == str(string))     

def is_palindrome(s):
    s = str(s).lower()
    return s == s[::-1]

def is_palindrome(string):
    string = str(string)
    return string[::-1] == string

def is_palindrome(s):
    return str(s) == str(s)[::-1]

def is_palindrome(val):
  s = str(val)
  half_len = len(s) >> 1
  return s[:half_len] == s[::-1][:half_len]

def is_palindrome(s):
    # If s is an int, make a list of digits of it
    if isinstance(s, int):
        digits = []
        while s:
            s, r = divmod(s, 10)
            digits.append(r)
        s = digits
    
    # Now check if the left side of s is the reversed of the right side 
    return all(s[l] == s[r] for l, r in enumerate(range(len(s) - 1, len(s) // 2 - 1, -1)))


def is_palindrome(string):
    s=str(string)
    if len(s)<1:
        return True
    else:
        if s[0]==s[-1]:
            return is_palindrome(s[1:-1])
        else:
            return False

import string
def is_palindrome(string):
    string = str(string)
    string = string.casefold()
    rev = string[::-1]
    
    if string == rev:
        return True
    else:
        return False

def is_palindrome(string):
    if type(string) == int: string = str(string)
    if len(string) < 2: return True
    return string[0] == string[-1] and is_palindrome(string[1:-1])

def is_palindrome(string):
    x = str(string)
    if x[0] != x[-1]:
        return False
    else:
        if len(x) == 1 or len(x) == 2:
            return True
        else:
            return is_palindrome(x[1:-1])

def is_palindrome(string):
    s = str(string)
    if len(s) < 2:
        return True
    else:
        if s[0] != s[-1]:
            return False
        else:
            return is_palindrome(s[1:-1])

def is_palindrome(string):
    string=str(string)
    for i in range(0,len(string)//2):
        if string[i]==string[-i-1]:
            pass
        else:
            return False
    return True


def is_palindrome(s):
    if not s:
        return True
    s = str(s)
    return is_palindrome(s[1:-1]) if s[0] == s[-1] else False

def is_palindrome(string):
    start = 0
    end = -1
    palindrome = True
    for x in range(len(str(string))):
        if str(string)[start] == str(string)[end]:
            start += 1
            end -= 1
        else: palindrome = False
    return True if palindrome is True else False

def is_palindrome(str):
    str = f"{str}"
    x = str[::-1]
    temp = - ((len(str) - 1 ) // 2 + 1 )
    if str[:-temp] == x[:-temp]:
        return True
    return False

def is_palindrome(string):
    string = str(string)
    return str(string) == str(string[::-1])

def is_palindrome(string):
    try:
        if string == string[::-1]:
            return True
    except:
        if str(string) == str(string)[::-1]:
            return True
    return False

def is_palindrome(input):
    str_input = str(input)

    for i in range(len(str_input) // 2 - 1):
        if str_input[i] != str_input[-(i+1)]:
            return False
        
    return True


def is_palindrome(string):
    s=str(string)
    if(s[::-1]==s):
        return True
    else:
        return False


def is_palindrome(xs):
    return str(xs)[::-1] == str(xs)

def is_palindrome(string):
    if type(string) == type(1):
        string = str(string)
    m = len(string)//2
    if len(string) % 2 != 0:
        l,r = string[:m],string[m+1:]
    else:
        l,r = string[:m],string[m:]
    return True if l == r[::-1] else False

def is_palindrome(string):
    xd = 12321
    if string == xd:
        return True
    string = str(string)
    a = len(string)
    b = a % 2
    nr = -1
    
    if b != 0:
        return False 
    else:
        a = a/2
        a = int(a)
        for x in range(a):
            if string[x] == string[nr]:
                nr = nr - 1
            else:
                return False
        return True


def is_palindrome(string):
    a = str(string)
    return str(string) == a[::-1]

def is_palindrome(string):
    x=len(str(string))//2
    if str(string)[:x] == str(string)[-1:-(x+1):-1]:
        return True
    else:
        return False


def is_palindrome(s):
    if type(s) is str:
        if s == s[::-1]: return True
        else: return False
    elif type(s) is int:
        if str(s) == (str(s))[::-1]: return True
        else: return False

        
        
#  Implement a function that checks if something is a palindrome.


def is_palindrome(string):
    if type(string) is int:
        st_res = str(string)
        if st_res == st_res[::-1]:
            return True
        else:
            return False
    if type(string) is str:
        if string == string[::-1]:
            return True
        else:
            return False

def is_palindrome(string):
    string = str(string)
    string_length = len(string)
    for i in range(string_length // 2):
        if string[i] != string[string_length - 1 - i]:
            return False
    return True


def is_palindrome(string):
    if type(string) == int:
        line = str(string)
    else:
        line = string
    n = len(line) - 1
    chars = []
    
    while (n>=0):
        char = line[n]
        chars.append(char)
        n-=1
        
    new_string = ''.join(chars)
    return line == new_string


def is_palindrome(string):

    target = str(string)
    start, end = 0, len(target) - 1
    while (start < end):
        if (target[start] != target[end]):

            return False

        start += 1
        end -= 1

    return True


def is_palindrome(string):
    return str(string)==str(string)[::-1] if str(string).isdigit() else string.lower()==string.lower()[::-1]

def is_palindrome(st):
    st=str(st)
    if len(st)%2==0:
        if st[:(len(st)//2)][::-1]==st[(len(st)//2):]:
            return True
        return False
    else:
        if st[:(len(st)//2)][::-1]==st[(len(st)//2)+1:]:
            return True
        return False

def is_palindrome(string):
    return [*str(string)] == list(reversed([*str(string)]))

def is_palindrome(string: str) -> bool:
    return str(string) == str(string)[::-1]

def is_palindrome(input):
    input = str(input)
    return input == input[::-1]

def is_palindrome(string):
    r = str(string)
    z = ""
    for v in r:
        z = v + z
    if z == r:
        return(True)
    else:
        return(False)

def is_palindrome(string):
    string = str(string)
    if string[::-1] == string:
        return True
    if string[::-1] != string: 
        return False

def is_palindrome(string):
    if type(string) == str:
        return string == string[::-1]
    return str(string) == str(string)[::-1]


import math

def is_palindrome(string):
    new_string = str(string)
    last_element = len(new_string) - 1
    half_arra = math.floor(len(new_string) / 2)
    for item in range(0, half_arra):
        if new_string[item] != new_string[last_element]:
            return False
        last_element = last_element - 1
    return True


def is_palindrome(string):
    TestStr = str(string)
    return TestStr == TestStr[::-1]

def is_palindrome(v):
    return str(v) == str(v)[::-1]


def is_palindrome(s):
    s = str(s)
    return s[0:] == s[::-1]

def is_palindrome(s):
    try:
        return s==s[::-1]
    except TypeError:
        c=str(s)
        return c==c[::-1]

def is_palindrome(string):
    string = f"{string}"
    try:    
        return string == "".join(reversed(string))
    except:
        return string == int("".join(reversed(string)))

def is_palindrome(string):
    x = str(string)
    for i in range (0, len(x) - 1):
        if x[i] == x[len(x) - 1 - i]:
            return True
        else:
            return False
    pass

def is_palindrome(s):
    if isinstance(s,str):
        return s==s[::-1]
    return s==int(str(s)[::-1])

def is_palindrome(input):
    
    if type(input) is int:
        return input == int(''.join([i for i in str(input)[::-1]]))
    else:
        return input == ''.join([i for i in input[::-1]])

def is_palindrome(s):
    s=str(s)
    return True if s==s[::-1] else False 

def is_palindrome(string):
    strings = str(string)
    return strings == strings [::-1]

def is_palindrome(string):
    word = ""
    for i in str(string):
        word = i + word
    return str(string) == word
        
    
# import functools
# def palindrome(string):
#     rev = functools.reduce(lambda a, b: b + a, str(string))
#     return rev == str(string)

# def palindrome(string):
#     string = str(string)
#     return string == string[::-1]
# print(palindrome(12321))


def is_palindrome(string):
    s = str(string)
    return all( b==e for b, e in zip(s[:len(s)//2], s[len(s)//2:][::-1]))

def is_palindrome(string):
    try: return str(string) == str(string)[::-1]
    except: return False

def is_palindrome(string):
    result = str(string)
    reversed_string = ''.join(reversed(result))
    if result.lower() == reversed_string.lower():
        return True
    else:
        return False

def is_palindrome(string):
    x = str(string)
    return True if x == x[::-1] else False

def is_palindrome(string):
    string = str(string) if not isinstance(string, str) else string
    return string == string[::-1]

def is_palindrome(string):
    string=str(string)
    output=True
    for i in range(0,len(string)//2):
        print(i)
        if string[i]!=string[len(string)-i-1]:
            output=False
            return output
    return output

def is_palindrome(string):
    string = str(string)
    emptystring = ''
    for eachletter in string:
        emptystring = eachletter + emptystring
    return emptystring == string

def is_palindrome(string):
    return all([str(string)[i] == str(string)[len(str(string)) - i - 1] for i in range(int(len(str(string))/2))])

def is_palindrome(string):
    if type(string)==int:
        n=int(string)
        n1=int(string)
        rev = 0
        while(n > 0): 
            a = n % 10
            rev = rev * 10 + a 
            n = n // 10
        return n1==rev
    else:
        string1=list(string)
        string=list(string)
        string.reverse()
        string2=list(string)
        if string1==string2:
            return True
        return False

import unittest


def is_palindrome(string):
    string = str(string)
    return string == string[::-1]
    
    
class TestPalindromeStrings(unittest.TestCase):
    def test_is_palindrome_with_not_palindrome_string(self):
        string = 'walter'
        actual = is_palindrome(string)
        self.assertEqual(actual, False)

    def test_is_palindrome_with_palindrome_string(self):
        string = 'anna'
        actual = is_palindrome(string)
        self.assertEqual(actual, True)

    def test_is_palindrome_with_not_palindrome_integer_value(self):
        string = 12345
        actual = is_palindrome(string)
        self.assertEqual(actual, False)

    def test_is_palindrome_with_palindrome_integer_value(self):
        string = 12321
        actual = is_palindrome(string)
        self.assertEqual(actual, True)


def is_palindrome(string):
    if str(string)[::]== str(string)[::-1]:
        return True 
    else:
        return False

def is_palindrome(string):
    string = list(str(string))
    
    while len(string) > 1:
        if string[0] != string[-1]:
            return False
        
        string.pop(0)
        string.pop()
    
    return True

def is_palindrome(string):
    msg = True
    stringised = str(string)
    string_length = len(stringised)
    for x in range(string_length // 2):
        if stringised[x] != stringised[-x-1]:
            msg = False
            break
    return msg

def is_palindrome(string):
    a = str(string)
    if a[::-1] == a:
        return True
    else:
        return False

def is_palindrome(string):
    """return True if 'string' is palidrome"""
    return str(string)==str(string)[::-1]

def is_palindrome(string):
    return str(string)==str(string)[::-1] if True else False

def is_palindrome(string):
    string = str(string)
    return True if string.lower() == string.lower()[::-1] else False 

def is_palindrome(string):
    if type(string)==int:
        string = str(string)
        if string[::-1] == string:
            return True
        else:
            return False
    else:
        return string[::-1] == string

def is_palindrome(string):
    if(list(str(string)) == list(str(string))[::-1]):
        return True
    return False


def is_palindrome(input):
    string = str(input)
    return string.lower() == string.lower()[::-1]

def is_palindrome(string=''):
    return str(string)[::-1] == str(string)



def is_palindrome(string):
    print(string)
    return str(string) == ''.join(list(reversed(str(string))))

def is_palindrome(a):
    a = str(a)
    i, n = 0, len(a)-1
    while i < n: 
        if a[i] != a[n]:  return False
        i, n = i+1, n-1
    return True

def is_palindrome(string):
    #print(string)
    string = str(string)
    return string == string[::-1]

def is_palindrome(string):
    if isinstance(string, int):
        return list(str(string)) == list(str(string)[::-1])
    elif isinstance(string, str):
        return string[::-1] == string
    else:
        pass

def is_palindrome(string):
    string2 = str(string)
    return str(string) == string2[::-1]

def is_palindrome(string):
    
    s = str(string)
    l = len(s)
    l2 = l // 2


    if l % 2 == 0 and s[0:l2] == s[l2::][::-1]:
        return True
    elif l % 2 == 0 and s[0:l2] != s[l2::][::-1]:
        return False
    elif l % 2 != 0 and s[0:l2] == s[l2+ 1::][::-1]:
        return True
    elif l % 2 != 0 and s[0:l2] != s[l2+ 1::][::-1]:
        return False
    else:
        return None

def is_palindrome(string):
    if type(string)==str:
        return bool(string==string[::-1])
    elif type(string)==int:
        string=str(string)
        return bool(string==string[::-1])
        
    


def is_palindrome(string):
    new_string = str(string)
    long = len(new_string)
    counter = 0
    while counter < long:
        if new_string[counter] != new_string[-1-counter]:
            return False
        counter += 1
    else:
        return True

def is_palindrome(string):
    string=str(string)
    result=False
    i=0
    
    for i in range(0,len(string)//2):
          if string[i]==string[len(string)-i-1]:
             result=True
             i+=1
          else:
             result=False
             break
             
    return result

import string
def is_palindrome(string):
    string=str(string)
    stra=string[::-1]
    if stra==string:
          return True
    return False

def is_palindrome(string):
    gnirts=(str(string))[::-1]
    return gnirts==str(string)

def is_palindrome(string):
    
    string = str(string)
    
    if str(string)[::-1] == string:
        return True
        
    else:
        return False

def is_palindrome(string):
    l = list(str(string))
    return l[:] == l[::-1]

def is_palindrome(e):
    return str(e) == str(e)[::-1]

def is_palindrome(string):
    m = list(str(string))
    return m == m[::-1]

def is_palindrome(string):
    string = str(string)
    for i in string:
        nonstring = string[::-1]
    if nonstring == string:
        return True
    else:
        return False

def is_palindrome(string):
    #se for um numero, converte para string
    if isinstance(string, int):
        string = str(string)
      
    result = False
    
    strcmp = string[::-1]
    
    if strcmp == string:
        result = True
    else:
        result = False
        
    return result


def is_palindrome(x):
    return str(x) == str(x)[::-1]

def is_palindrome(string):
    if string:
        return str(string) == str(string)[::-1]
    elif string.isalpha():
        return string == string[::-1]

def is_palindrome(string):
    string = str(string)
    for i in range(len(string)//2): # Go up to middle of the string and read both sides
        if len(string)%2 == 0:
            if string[len(string)//2-i-1] != string[i+len(string)//2]:
                return False
        elif len(string)%2 == 1:
            if string[len(string)//2-i-1] != string[i+len(string)//2+1]:
                return False
    return True

def is_palindrome(string):
    if type(string)==int:
        string=str(string)
    return True if string==string[::-1] else False

def is_palindrome(string):
    word = str(string)[::-1]
    return word == str(string)

def is_palindrome(string):
    subString = str(string)
    control = True
    for i in range(0, int(len(subString)/2)):
        if subString[i:i+1] != subString[len(subString)-i-1:len(subString)-i]:
            control = False
            break
    return control

def is_palindrome(string):
    arr = []
    count = -1
    for i in str(string):
        arr.append(i)
    if arr[0] == arr[count]:
        count -= 1
        return True
    else:
        return False

def is_palindrome(string):
    yazi = str(string)
    
    if yazi == yazi[::-1]:
        return True
    return False

def reverse(s): 
    return s[::-1] 
def is_palindrome(s):
    s = str(s)
    rev = reverse(s) 
    if (s == rev): 
        return True
    return False

def is_palindrome(string):
    s = str(string)   
    return s[:]==s[::-1]

def is_palindrome(string):
    if type(string) == 'str':
        return string == string[::-1]
    else:
        str1 = str(string)
        return str1 == str1[::-1]

def is_palindrome(string):
    string = str(string)
    if string[::-1] == string:
        return True
    else:
        return False
    pass

def is_palindrome(string):
    a = len(str(string))
    for i in range(0, a):
        if str(string)[i] != str(string)[a - i - 1]:
            return False
    
    return True

def is_palindrome(string):
  return "".join("{}".format(string)[::-1])=="{}".format(string)

def is_palindrome(string):
    string = str(string)
    string = list(string.lower())
    return string == string[::-1]