# Palindromes 2021-11-08

Keywords: Python Algorithm leetcode

## Determine whether an integer is palindrome

Title Description:
Source: LeetCode 09 palindromes
Give you an integer x, if x is a palindrome integer, return true; Otherwise, return false.

Palindrome numbers refer to integers whose positive order (left-to-right) and reverse order (right-to-left) are read the same. For example, 121 is palindrome and 123 is not.

Example 1:

Input: x = 121
Output:true
Example 2:

Input: x = -121
Output: false
Explanation: Read from left to right, -121. Read from right to left, 121-. So it's not a palindrome number.
Example 3:

Input: x = 10
Output: false
Explanation: Read from right to left, 01. So it's not a palindrome number.
Example 4:

Input: x = -101
Output: false

Can you solve this problem by converting integers to strings?

```class Solution:
def isPalindrome(self, x: int) -> bool:
str1 = str(x)
flag = True
for i in range(0, int(len(str1)/2)):
if str1[i] != str1[len(str1) - 1 -i]:
flag = False
break
return flag
```

Execution Result: Passed

Execution time: 56 ms, beating 75.91% of all Python 3 submissions
Memory consumption: 14.7 MB, beating 99.20% of all Python 3 submissions
Pass test case: 11510 / 11510

Idea: first find the number of integers, then divide this number by 10 through two for loops, then receive the high and high position numbers with end and start, and then compare if the start and end are equal, otherwise they are not palindromes

```class Solution:
def isPalindrome(self, x: int) -> bool:
count = 0
flag = True
number = x
number1 = number
if number1 < 0:
flag = False
while number1 > 0:
count += 1
number1 = int(number1/10)

for i in range(0,count):
end = number
start = number
#Get the number from the lowest bit in turn after the remainder operation
for j in range(0,i):
end = int(end/10)
#Get the number from the highest bit in turn after the remainder operation
for k in range(0,count - 1 - i):
start = int(start / 10)
if (start % 10) != (end % 10):
flag = False
break
return flag
```

Improvement:
Think: Use a while loop, divide by 10 and then take the rest back_number receives the inverse number of x, and finally determines if the inverse number is equal to the previous number

```class Solution:
def isPalindrome(self, x: int) -> bool:
back_number = 0
number1 = number2 = x
#If x is negative, then it must not be a loopback number
if x < 0:
return False
#Use back_by polling for dividing by 10 Number receives the inverse number of x
while number1 > 0:
back_number = (back_number * 10) + (number1 % 10)
number1 = int(number1 / 10)
return x == back_number
```

Idea: Is x >=0 equal to X after reverse order (list used)
(This submission defeated more than 60% of users, but it was the fastest I could find. None of the answers in the python area seems to be fast. That might be the reason for python. If any of the guys have a faster algorithm, please comment and tell me, thank you guys!)

```class Solution:
def isPalindrome(self, x: int) -> bool:
return x>=0 and int(str(x)[::-1]) == x
```

[: -1] Explanation: (Big man is 6)

```b = a[i:j]   # Represents copying a[i] to a[j-1] to generate a new list object
a = [0,1,2,3,4,5,6,7,8,9]
b = a[1:3]   # [1,2]
#When i defaults, the default is 0, that is, a[:3] equals a[0:3]
#When j defaults, the default is len(alist), which means a[1:] corresponds to a[1:10]
#When I and j are both default, a[:] is equivalent to a full copy of a
b = a[i:j:s]    # Representation: i,j i s the same as above, but s i s a step, defaulting to 1.
therefore a[i:j:1]Amount to a[i:j]
#When s<0, i defaults to -1. j, and -len(a)-1
#So a [:-1] corresponds to a[-1:-len(a)-1:-1], that is, to copy from the last element to the first element once, in reverse order.
```

Posted by Kol on Tue, 09 Nov 2021 09:09:23 -0800