thanks for making me more confused

Nice Solution! We can write the divider value in this way as well 8:37: if x==0: return True div = 10**int(math.log10(x))

Great solution, thank you! The solution implemented in c#: public bool IsPalindrome(int x) { if (x < 0) { return false; } long divider = 1; while (divider * 10 0) { int l = (int) (x / divider); int r = (int) (x % 10); if (l != r) { return false; } // Cut the left digit x = (int) (x % divider); // Cut the right digit x /= 10; divider /= 100; } return true; } divider is in long type due to case the given x is one digit less the max int value. Another solution, write the reserved number and compare it to the given x. implemented in c#: public bool IsPalindrome(int x) { if (x < 0) { return false; } int reservedNumber = 0; int originalX = x; while (x > 0) { int lastDigit = x % 10; reservedNumber = reservedNumber * 10 + lastDigit; x /= 10; } return reservedNumber == originalX; }

watched this and did it using strings, gave myself a pat on the back.

Simple, efficient and straight to the point. Thanks for this answer.

A simple solution using JS. The idea is to reverse the number and then compare it to the original one. var isPalindrome = function(x) { if (x < 0) return false; let num = x; let result = 0; while (num > 0) { result = result * 10 + (num % 10); num = Math.floor(num / 10); } return result === x; };

I feel like this is a simpler approach: public class Solution { public bool IsPalindrome(int x) { if(x < 0) return false; if (x != 0 && x % 10 == 0) return false; int original = x; int reversed = 0; while (x != 0) { reversed = reversed * 10 + x % 10; x /= 10; } return original == reversed; } }

This was my C# solution (which is similar to yours) that I submitted a while ago; if(x == 0) return true; if(x < 0 || x % 10 == 0) return false; var reverse = 0; while(x > reverse) { var lastDigit = x % 10; x /= 10; reverse = reverse * 10 + lastDigit; } return x == reverse || x == reverse / 10;

s = str(x) return s == s[::-1] This code is more effective and very simple to understand. Hope it was useful

I think this video may need a remake because it will not work when the input is 1410110141 on Java. I tried this and it worked: if (x < 0 || (x % 10 == 0 && x != 0)) { return false; } else { int original = x, reversed = 0; while (original > reversed) { reversed = (reversed * 10) + (original % 10); original /= 10; } return original == reversed || original == reversed / 10; }

Great explanation sir ... respect!

Thank you for the solution! But I’m struggling to understand why we should chop off the left and right digits, couldn’t we just compare then and if they are equal return True? Please if someone could explain, I would be much grateful!

Easiest Way Ever : def isPalindrome(self, x): num = x reverse = 0 while(x>0): lastdigit = x%10 reverse = reverse*10+lastdigit x = x//10 return True if reverse == num else False

congrats for 350K😍

you could use decimal log for finding the divider

A rather contrived problem. Not a fan. Great explanation though!

class Solution: def isPalindrome(self, x: int) -> bool: list1=[] import math y = [a for a in str(x)] for i in range(0,math.floor(len(y)/2)+1): if y[i]!=y[-i-1]: list1.append(1) else: list1.append(0) if 1 in list1: return False return True

Will this solution work for this testcase? 1000021 Because, once we remove the first and the last letter and proceed to the next step, we have 000021 which is evaluated as 21

Damm. I created a linked list and rebuilt the number in reverse and then compared it. And that too in C. 😭😭

thanks you for your solution brother !!

Do you know how to fix this code to work with 0’s on both ends, say you end up with 0110, I think the computer will ignore the first 0 so it’ll try to match 1 and 0 which will return false, idk if this happens on python but i’m doing it in java

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

why don't we just reverse the number and compare?

This solution will fail if the number contains "0" in the middle of a number right? Like 1000021

why do you assume 21/10 rounds down to 2?

Thank you!

Correct me if I am wrong but this solution is outdated. It fails for the test case 1000021.

can anyone tell me why you gotta use oops in this when it simply can be done using if else statement correct me if i am wrong heres my code btw x=121 y=str(x)[-1::-1] z=int(y) print(z) if x == z: print("Palindrome") else: print("not a palindrome") it didnt ran on leetcode showed some sort of runtime error

Sure it's a smart solution but who tf is coming up with this in an interview (unless you've memorised it)

heres mine class Solution: def isPalindrome(self, x: int) -> bool: z = str(x)[::-1] if z == str(x): return True else : return False

class Solution(object): def isPalindrome(self, x): b=str(x) c=b[::-1] if c==b: return True else: return False

this one needs update, doesn't work on x0000xx

wait there are pointers in python?

return str(x) == str(x)[::-1] Runtime: 115 ms, faster than 21.82% of Python3 online submissions for Palindrome Number. Memory Usage: 13.9 MB, less than 90.68% of Python3 online submissions for Palindrome Number.

It is interesting how the solution is here. Does it really work in python when the number is something like 10000001? My solution was something like this. It is enough fast but I wanted to have memory optimized. :( var isPalindrome = function(x) { if (x < 0) return false if (x < 10) return true var array = [] while (x != 0) { array.push(x % 10) x = parseInt(x / 10) } for (var i = 0; i< parseInt(array.length / 2); i++) { var start = array[i] var end = array[array.length - (i + 1)] if (start != end) return false } return true };

This does not work for a number like 100021

def isPalindrome(self, x: int) -> bool: x = str(x) if x[::-1] == x: return True else: return False

Nice explanation! What would be the time complexity of the solution? O(logN) ??

at 11:56 Why do we do div = div / 100 and not div = div/10 ?

damn, I just converted the number to a string, used [::-1] to turn it around, converted it to a number again with int, and compared it with the original x, I think something is wrong with me

we can simply change it to string?

Anyone knows why do we need to divide div by 100? The condition div = div // 100.

impresive

How about making inverted number (java) public boolean isPalindrome(int x) { if (x < 0) { return false; } int inverted = 0; for (int target = x; target != 0; target /= 10) { inverted = inverted * 10 + target % 10; } return inverted == x; }

can you give the same solution in java pls

wonderful video!

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

I did this in Java. Runtime and memory same to be the same as above solution. public boolean isPalindrome(int x) { if(x == 0) return true; if(x < 0 || x % 10 == 0) return false; List arr = new ArrayList(); while(x > 0){ int temp = x%10; x=x/10; arr.add(temp); } int start = 0, end = arr.size() - 1; while(start

O(log10N) , right?

The "Problem Link" is wrong in your description. Please correct it.

What if we just compare string with reversed string. Isn't that an easy solution? def isPalindrome(self, x: int) -> bool: if(x

Is this solution good? number = int(input()) list = [] new_list = list.append(number) print(list) string = str(number) new_string=string[::-1] new_string1 = int(new_string) list2 = [new_string1] if list[0]==list2[0]: print("It is pallindrome") else: print("It is not pallindrome")

Check this out, much easier to visualize class Solution: def isPalindrome(self, x: int) -> bool: if x

please solve top view and bottom view of binary tree

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

Does anyone came up with the c++ soln with this approach

First again ❤️

What a stupid problem

this is wrong

Will this work? x_str = str(x) return x_str == x_str[::-1]

Thank you!