Reverse Integer - Bit Manipulation - Leetcode 7

Reverse Integer - Bit Manipulation - Leetcode 7 - Python

Рет қаралды 77,307

Күн бұрын

🚀 neetcode.io/ - A better way to prepare for Coding Interviews
🐦 Twitter: / neetcode1
🥷 Discord: / discord
🐮 Support the channel: / neetcode
Twitter: / neetcode1
Discord: / discord
✔️ SPREADSHEET BLIND-75: docs.google.com/spreadsheets/...
Code on Github: github.com/neetcode-gh/leetco...
⭐ BLIND-75 PLAYLIST: • Two Sum - Leetcode 1 -...
💡 CODING SOLUTIONS: • Coding Interview Solut...
💡 DYNAMIC PROGRAMMING PLAYLIST: • House Robber - Leetco...
🌲 TREE PLAYLIST: • Invert Binary Tree - D...
💡 GRAPH PLAYLIST: • Course Schedule - Grap...
💡 BACKTRACKING PLAYLIST: • Word Search - Backtrac...
💡 LINKED LIST PLAYLIST: • Reverse Linked List - ...
💡 BINARY SEARCH PLAYLIST: • Binary Search
Problem Link: neetcode.io/problems/reverse-...
0:00 - Read the problem
5:07 - Drawing Explanation
9:05 - Coding Explanation
leetcode 7
This question was identified as a google interview question from here: github.com/xizhengszhang/Leet...
#bit #manipulation #python
Disclosure: Some of the links above may be affiliate links, from which I may earn a small commission.

Пікірлер: 142

@Ynno2 9 ай бұрын

Crazy how like 90% of the most upvoted Python solutions on this problem didn't understand or just ignored the constraint on staying within 32 bits.

@bhaskyOld 2 жыл бұрын

Great explanation. Just a question, in case of "res == MAX//10", the digit needs to be grater than 7 to overflow, not grater than equal.

@jjayguy23 Жыл бұрын

I think you're right.

@arpitagarwal1741 2 жыл бұрын

Instead of `digit >= MAX%10` and `digit

@Ynno2 9 ай бұрын

Those conditions can just be deleted, it's unreachable code.

@infiniteloop5449 Жыл бұрын

Just finished this problem as the final problem of the NeetCode 150! Neetcode ALL TIME!

@gitarowydominik 6 ай бұрын

This solution clearly has nothing to do with BIT MANIPULATION. :)

@yuvrajparmar0 2 жыл бұрын

finally a correct solution I was looking for. Thanks for the explanation.

@romelpascua 3 жыл бұрын

I searched if you had solved this question just last night. You read my mind!

@veliea5160 3 жыл бұрын

our guy is getting more popular :)

@NeetCode 3 жыл бұрын

🤓

@untrall6667 2 жыл бұрын

I think MIN should also use int(math.fmod(MIN, 10)) and int(MIN / 10)

@shrn 6 ай бұрын

Yep

@ssiddique_info 2 жыл бұрын

MIN is a negative number, why MIN % 10 will work fine but % will not work for a negative number in line 11?

@kkvvy 2 жыл бұрын

Clear explanation for integer overflow ! Thx !

@applepaul Жыл бұрын

why do we need to check (res > INT_MAX/10 || (res == INT_MAX/10 && digit > INT_MAX%10)) *based on the input size* : between -2^31 to 2^31 - 1, *we can never have the first digit (from left) of any input to be greater than 2*. So when we reverse this number, the units place (first from right) can never have any number greater than 2. This condition gets *set by default due to the constraints on input* So even if we remove this piece from the code, it should run fine

@praveendantam7033 Жыл бұрын

Here you mentioned bit manipulation, but it seems you didn't used bit manipulation. Can we do this problem using bit manipulation? Anyone please clarify this to me. Thanks in advance!

@aryanyadav3926 2 жыл бұрын

Thanks for the wonderful explanation!

@craignemeth942 2 жыл бұрын

Why is this under bit manipulation on neetcode? I was going insane trying to figure out some cool bit manipulation method that must exist when I could clearly see it was a problem to be solved in base 10 not base 2...

@TwoTeaTee 9 ай бұрын

Right! Kept me scratching my head!

@cheeniipapa 7 күн бұрын

@Raphael-bq1fc 2 жыл бұрын

I think this guy's solutions are the best

@ekoyanachi 2 жыл бұрын

Thanks for solving the problem. Can you provide detail on where bit manipulatin is used while reversing integer?

@AlexN2022 Жыл бұрын

This is suboptimal, since you dp a division - a slow operation - on every iteration of the loop. Instead, as you reconstruct your reversed number low-to-high , it's only the highest power of 10 that can overflow the result. So you can go 10^(0->8) without checks, and then just do two checks - two divisions - before adding the final 10^9. Suppose i==0 and ten_power==10^9 if(INT_MIN / ten_power > digits[i]) { return 0; // can we even multiply this number by 10^9? } if(result < INT_MIN - digits[i] * ten_power) { return 0; // will it overflow if we add it to our result? } result += digits[i] * ten_power; // result is always negative

@huberttiddlywinks1445 Ай бұрын

You don't need to check any conditions inside the loop because you'll only go outside the range once you hit the last iteration. Simply reverse the input normally and check if res < INT_MIN || res > INT_MAX before returning. Remember that the input is constrained to -2^31

@John-ye8sj Жыл бұрын

one can also check for overflow: a + b > INT_MAX a > INT_MAX - b (it will overflow) or underflow: assume a < 0 a + b < INT_MIN b < INT_MIN - a (it will underflow; INT_MIN - a is safe, because a is negative and the operation will be a sum in the end)

@mohsen2088 Жыл бұрын

great explanation. thanks for all the efforts

@thankmelater9774 2 жыл бұрын

I have the simplest solution without worrying about the overflows. Make a simple reverse method. int reverse = getReverse(x); Then, find reverse of reverse, int reverseOfReverse = getReverse(reverse) Check if reverserOfReverse and x are same (after removing trailing zeros from x, like for 120, and 21 case) If both are same then return reverse Else some overflow had occurred during reversal, and return 0

@BitsandAtoms Жыл бұрын

Well, that's not really a solution -- it's more of a hack. And it depends on the platform it is being run on, and is a total misuse of error handling. It won't work if the underlying VM or system can actually handle a 64 bit integer, and nobody ever wants code that relies on exception handling to get a result in a real production situation. It's pretty much a B-line toward putting your resume in the trash bin for the interviewer.

@romo119 Жыл бұрын

@@BitsandAtoms If it can handle a 64 bit integer, why aren't we using one in the solution itself? And why is this considered an exception? These boundary conditions is expected behavior, otherwise it would actually throw an exception right? Also aren't these leetcode questions meant for you to solve a problem within specific confines? And why are you not allowed to assume that the behavior of x language is the expected behavior?

@bitsandatoms8008 Жыл бұрын

@@romo119 You are allowed to do it and it will work. It's garbage coding practice though and if you want to get a job as a programmer you need to write good, maintainable code that doesn't use lazy hacks.

@CostaKazistov 2 жыл бұрын

LeetCode problem 7 Reverse Integer - difficulty is now Medium

@NeetCode 2 жыл бұрын

That's good, it's definitely not easy

@lumsism 2 жыл бұрын

Another way to do it def reverse(x): res = 0 if x < 0: symbol = -1 x = -x else: symbol = 1 while x: popped = x % 10 res = res * 10 + popped x //= 10 return 0 if res > 2**31 else res*symbol

@danielghenghea7104 2 жыл бұрын

Defeats the whole purpose-- you're assuming that res is represented correctly as a 64-bit integer, but the problem clearly states that we are not allowed to do this.

@mrtech7940 Жыл бұрын

mate ,your code is way better than those in the video

@r.varshitha7459 2 ай бұрын

You don't need to check the condition res==MAX//10 && digit>=MAX%10 cause this would mean that the input should be 7463847412 ( reverse of 2147483647). This is outside the int range as in the question they mentioned the input is an integer. Similarly you also can avoid the res==MIN//10 && digit

@ajitsdeshpande 4 ай бұрын

@Neetcode - I think the second part of the if conditions should be using on greater than and less than checks, rather than what you have >= , MAX % 10

@ajitsdeshpande 4 ай бұрын

Because if the reversed digit is equal to MAX , it is not considered overflow or if negative number is equal to MIN , it is not underflow

@codiosity 2 ай бұрын

yo thanks man , the course i followed has years ago solution , at that time it was in easy problem , now its medium , they had not added the constrainst prolly

@discostitches826 2 ай бұрын

I found this a really helpful explanation.

@dynamicuno666 7 ай бұрын

For guys struggling with Java, there is a simple way to determine integer overflow. You can directly store a temporary reverse result. If the reverse result divided by 10 does not equal the previous result, there is an overflow. The complete code is provided below: public int reverse(int x) { int res = 0; while (x != 0) { int temp = res * 10 + x % 10; if (temp / 10 != res) { // overflow return 0; } res = temp; x /= 10; } return res; }

@sapnavats9105 3 жыл бұрын

Please solve leetcode problem 493. Reverse Pairs. I've been stuck on it since morning. Cannot seem to find any breakthrough. In this question, the Java and C approach when applied using python yields TLE.

@danielsun716 2 жыл бұрын

thanks for the sharing, that is so good. but I am wondering the two "if " condition may be "if res > MAX // 10 or (res == MAX // 10 and digit > MAX % 10):" and "if res < MIN // 10 or (res == MIN // 10 and digit < MIN % 10):" it should be less or greater not less or equal or greater or equal, cause the condition the problem give me does include 2^31 - 1 and -2^31. However, the intheresting thing is both solution can pass.

@daliakhateb32 Жыл бұрын

even if digit>1 it will pass, because in order that res==max% 10, the input must be i463847412 and i can't be greater than 1

@giftsonvasanth3026 2 жыл бұрын

class Solution(object): def reverse(self, x): """ :type x: int :rtype: int """ min =-2147483648; max = 2147483647; res = 0; while x: digit = int(math.fmod(x,10)); x=int(x/10); if (res > max//10 or (res == max//10 and digit >= max % 10)): return 0; if(res < min//10 or (res == min//10 and digit

@shiwanshumani9928 23 күн бұрын

Run on python3

@huybv1998 Жыл бұрын

or you can simply convert from int to string, reverse it with [::-1], in case if there is a "-" character, just remove it at first and add "-" again before reversing the string. And then reconvert to int, it's much faster

@muhammadmujtaba3852 Жыл бұрын

But the space complexity will be huge

@Ynno2 9 ай бұрын

Except it breaks the rules of the problem. You can't do this within 32-bits. 1000000009 reversed would be 9000000001, which has a 35-bit signed integer representation. Leetcode won't reject it because they don't verify the internal state of your code, but you wouldn't be able to cheat like that with a real human. Honestly, any solution which uses a conversion to string I'd expect to be rejected by the interviewer. If you aren't allowed to use a 64-bit integer, using a 80-bit string (for a ten digit input) doesn't seem like it would be acceptable.

@yilinliu2238 3 жыл бұрын

can you make more videos on bit manipulation XOR such as missing number (268) please

@laineyv6434 2 жыл бұрын

Check if negative, convert to string, reverse digits, convert back to number

@vncoolestguy 2 жыл бұрын

sorter def reverse(self, x: int) -> int: s = abs(x) rs = 0 while s: temp = s % 10 s = s//10 if rs > math.pow(2,31) // 10: return 0 break rs = rs*10 + temp return rs if x>0 else -rs

@Manu-et6zk 3 жыл бұрын

class Solution { public int reverse(int x) { long res = 0; while(x!=0){ res = res * 10 + x%10; x = x/10; } if(res < Integer.MIN_VALUE || res > Integer.MAX_VALUE){ return 0; }else{ return (int) res; } } }

@THEkarankaira 3 жыл бұрын

we cannot use long

@anudeepreddy1027 Жыл бұрын

Can we use result%mod where mod= pow(2, 31) -1 if the result value has decreased from its previous value we can return 0 ?

@akhileshverma4039 Жыл бұрын

At 10:30 the operations are correct according to Mathematics. In math, A=Q*B+M which is exactly it is giving. Other languages use the result of division algorithm which is anticipated in here but mathematically this behaviour seems appropriate.

@akhileshverma4039 Жыл бұрын

where 0

@aniketchavan2271 8 ай бұрын

The above code return 0 ans for negative numbers. Following is the corrected code.. def reverse(self, x): MIN = -2147483648 MAX = 2147483647 is_negative = x < 0 x = abs(x) res = 0 while x: digit = x % 10 x //= 10 if res > MAX // 10 or (res == MAX // 10 and digit > MAX % 10): return 0 if res < MIN // 10 or (res == MIN // 10 and digit < MIN % 10): return 0 res = (res * 10) + digit return -res if is_negative else res

@srikrishnan8097 5 ай бұрын

I have just one doubt, if for reversing the number which is a negative integer you're using fmod to hold last value of the integer then how come in the second if statement you're not using fmod to get hold of the last value of min value. This is also true with floor division operator

@NHCS-ShreyasChaudhary Жыл бұрын

class Solution: def reverse(self, x: int) -> int: if x > 0: # handle positive numbers a = int(str(x)[::-1]) if x

@ganeshjaggineni4097 Ай бұрын

NICE SUPER EXCELLENT MOTIVATED

@Ynno2 9 ай бұрын

``` if res < MIN // 10 or (res == MIN // 10 and digit < MIN % 10): ``` `digit < MIN % 10` seems like *almost* bug since you're using regular % on the negative MIN, which will give a positive number (in this case `2`), whereas `digit` will always be zero or negative on this code path. However, It's not technically a bug because it's unreachable code. There's no case where `res == MIN // 10` is True where the digit will be invalid, so the condition will always be short-circuited. `digit < MIN % 10` could just be removed.

@goodwish1543 2 жыл бұрын

simpler logic, for x > 0, pop = x % 10, if ( rev > (INT_MAX - pop)//10 ) : return 0;

@jiteshsharma3388 3 ай бұрын

Can someone confirm the Time complexity? I think it will be O(1) because loop will always run 10 time due to our overflow condition. or it will O(x) where x is number of digits?

@kingrudong9761 3 ай бұрын

Use return res if abs(res) < 0x80000000 else 0 or you can use return res if abs(res)

@alexm1930 2 жыл бұрын

There are unneeded checks in your overflow logic. You only really have to check if((ret > INT_MAX / 10) || (ret < INT_MIN / 10)). The reason being is that an input such as your example's 81463847412 is not possible since the input parameter is a 32 bit integer. I did this problem in C++ and I was originally just going to detect overflows after the operation but leetcode just throws an exception. I'm not sure if python allows 64 bit integers as an input parameter since it's not a typed language, but for C++ trying an input value that doesn't fit a 32 bit integer will not allow the code to run.

@yunlongjia5380 2 жыл бұрын

Yes, I agree with you. This input is impossile.

@ishwaragarwal6740 2 жыл бұрын

[1-7]463847412 is a valid input and will fail if we only check second to last bit

@maamounhajnajeeb209 Жыл бұрын

thanks man

@pyinit6257 2 жыл бұрын

class Solution: def reverse(self, x: int) -> int: rev_x = int("-"+str(x)[::-1][:-1]) if x= 32 else rev_x This is how I solved it... I hope this method is not frowned upon. It seems weirdly short

@dumbchatter6475 2 жыл бұрын

This beats 96% on both memory and time

@darkwalker9755 2 жыл бұрын

because you do the reversing in your code then u check if it is within a range, in this exercice the idea is that your memory can't handle it so you should stop the code and return 0 if you overflow

@KarthikNandanavanam Ай бұрын

If Reverse is not able to fit in 32-bit. How come Input fit in 32-bit integer?

@kanchankrishna3686 2 жыл бұрын

Quick question: why cant you just check if res < INT_MIN or res > INT_MAX? Thank you for the video.

@DJ-vx9gl Жыл бұрын

That would work, but the question stipulates that 64-bit integers are not supported. If your res > INT_MAX or res < INT_MIN, it means res no longer fits in a 32 bit integer, so that's not allowed.

@siddharthsingh-cw4sd Жыл бұрын

Adbuuutttt!!!! amazing video

@user-oy4kf5wr8l 2 ай бұрын

great, thank you.

@_ayo 2 жыл бұрын

Thanks for the great explanation. But why are the "hacks" used in lines 11 & 12 of the code (for dumb python 🙂) not used in lines 14 - 18?

@Saurabhsingh-cl7px 2 жыл бұрын

Exactly

@Saurabhsingh-cl7px 2 жыл бұрын

Did u find the same problem ?

@_ayo 2 жыл бұрын

@@Saurabhsingh-cl7px Yeah, I guess it was an oversight on his part.

@anonymoustv8604 2 жыл бұрын

because that hack is only used for negative numbers. Since MIN is a constant number, MIN % 10 is 8. He could've just put 8 tbh, but it doesn't matter. Same for MAX % 10, it's 7. You can put 7 there and it will still work

@tsunghan_yu 2 жыл бұрын

@@anonymoustv8604 What do you mean? MIN *is* a negative number.

@tonyiommisg 9 ай бұрын

They've updated this to be a medium problem now in leetcode

@awesome_ashu Жыл бұрын

Shouldn't the condition be: if(ans > Integer.MAX_VALUE/10 || (ans == Integer.MAX_VALUE/10 && d > Integer.MAX_VALUE%10)) return 0; if(ans < Integer.MIN_VALUE/10 || (ans == Integer.MIN_VALUE/10 && d < Integer.MIN_VALUE%10)) return 0; The last digit can be equal but not greater?

@shraddhagami7910 2 жыл бұрын

div in python of negative numbers is giving different answer(not python3**)

@tonyiommisg 9 ай бұрын

Python still acts wonky with int(x/10). In my case it's still rounding down to the lowest number. In the case of -123, it's return -13.

@illu1na 9 ай бұрын

returning -12 when i just tested in for python3

@leeroymlg4692 Жыл бұрын

Is it against the rules to turn x into a string or something? Because all I did was convert x into a string, reverse it, and convert it back into an integer. Then check if it's within the -2^31 2^31 range. Made it the easiest leetcode problem I've solved.

@Ynno2 9 ай бұрын

> Because all I did was convert x into a string, reverse it, and convert it back into an integer. This requires up to 35 bits for the signed integer representation. If the input is -1000000009, then you are storing the integer -9000000001. That's 10111100111100011101110010111111111 in 2's complement signed representation. You can just count the bits. Positive 9000000001 also requires 35-bits, but it's a bit less obvious from just looking at it because it has a leading zero as the sign bit. It's debatable whether you should use a string (I'd personally say no), but I think it's pretty clear you can't use an integer greater than 32 bits. You ignored the constraints in the description which due to limitations of the Leetcode runtime environment it can't enforce.

@bulioh 5 ай бұрын

I think if once you converted it back into an integer and it happened to be outside the range, it's already against the rules. The goal is to never allow any integer (not just the result) to get outside that range in the first place, at least that's my understanding

@rabbyhossain6150 8 ай бұрын

I wonder, how can someone possibly remember these values during a real interview?

@hemesh5663 2 жыл бұрын

class Solution: def reverse(self, x: int) -> int: y = x< 0 x = abs(x) revs = 0 MIN = -2147483648 MAX = 2147483647 while x > 0: rem = x%10 revs = revs*10 + rem x =x//10 if MIN

@NeetCode 2 жыл бұрын

Yes this is very good since you use O(1) memory. In some ways i prefer this solution to mine in the video.

@hemesh5663 2 жыл бұрын

@@NeetCode I have a doubt in interview shd I focus on time or space complexity as there is trade off

@christianp3388 2 жыл бұрын

The problem with this solution is that variable "revs" will store an integer outside of the range [-2^31, 2^31 - 1]

@hemesh5663 2 жыл бұрын

@@christianp3388 I have checked it using that if condition whether revs is between my min and max

@christianp3388 2 жыл бұрын

@@hemesh5663 6:26 " how could we detect that this integer overflows without actually calculating it". Your code allows revs to calculate a value that overflows, i.e. a value outside of the specified range.

@infinityking194 Жыл бұрын

Why is this problem under Bit manipulation?

@codedaily365 Жыл бұрын

x=231 res='' if x < 0: y=str(x)[1::] for i in reversed(y): res=res+str(i) ans=res.strip('0') if -2**31

@sandstorm973 2 жыл бұрын

Why doesn't this approach work in JavaScript?

@apurvatripathi7633 Жыл бұрын

Java Code: class Solution { public int reverse(int x) { StringBuilder s = new StringBuilder(); s.append(x); char sign = '+'; if(s.charAt(0) == '-') { sign = s.charAt(0); s.delete(0,1); } s.reverse(); long val = Long.parseLong(s.toString()); if(val > Integer.MAX_VALUE || val < Integer.MIN_VALUE) return 0; if(sign == '-') return -1 * (int) val; return (int) val; } }

@aayushsaini9363 2 жыл бұрын

Why can't we just check if number is greater than Int. MAX-VALUE and if this is the case return 0?

@Ynno2 9 ай бұрын

Because the problem description says: Assume the environment does not allow you to store 64-bit integers (signed or unsigned). I.e. only use 32-bit integers or smaller. MAX is literally the maximum value you can store in a 32-bit signed integer, it's impossible that any signed 32-bit could be greater than it. If you have a number that is bigger that it, you already broke the rules.

@rabbyhossain6150 Жыл бұрын

Can't understand why we are using two different ways of mod: int(math.fmod(x, 10)) MIN_INT % 10

@Ynno2 9 ай бұрын

It's a mistake, but `MIN_INT % 10` is actually never evaluated. You can delete that condition and the result will be identical.

@user-lm3jn7wh7k 9 ай бұрын

The following is a much easier way, please have a look: def reverse(self, x: int) -> int: upper_limit = (2**31) - 1 lower_limit = (-2**31) if x > 0: x = str(x) x = x[::-1] x = int(x) if x in range(lower_limit, upper_limit): return x else: return 0 elif x < 0: x = str(x) x1 = x[0] x = x.replace("-","") x = x[::-1] x1 += x x1 = int(x1) if x1 in range(lower_limit, upper_limit): return x1 else: return 0 else: return 0

@g.deepakkrishnaa3847 9 ай бұрын

Anyone can do this with a string implementation. Companies want to know how you are going to manipulate a number using bit manipulation techniques, not strings

@markolainovic Жыл бұрын

I don't know if it's just me, but this looks more complicated than it needs to be 😅 I would just treat both negative and positive cases with the same code and put all conditions into one if statement, like this: ``` class Solution: def reverse(self, x: int) -> int: negative = x < 0 x = x if not negative else (-1) * x limit = 2**31 - 1 if not negative else 2**31 res = 0 while x != 0: if res > (limit - x % 10) // 10: return 0 res = res * 10 + x % 10 x //= 10 return res if not negative else (-1) * res ```

@romo119 Жыл бұрын

Apparently this is a "hack" according to "Pasquale Ranalli" and "Bits and Atoms" in above comment. I don't think it's a hack at all and I would accept this solution as an interviewer

@lackbeard2 9 ай бұрын

Won't your solution fail immediately on this line: x = x if not negative else (-1) * x When your input is -2^31, x will overflow.

@8nehe 2 жыл бұрын

"Python is dumb" killed me😂😂. Thanks for the great explanation

@EgorChebotarev Ай бұрын

nice

@ankitsablok952 2 жыл бұрын

The explanation offered in the video is not that great, this is a math problem and he is coming up with raucous ways to just add more overflow detection logic than is required. Please, don't over-engineer the solution as it makes it difficult to understand.

@user-je4fc9nx6i 4 ай бұрын

you will get the error for negative value for this problem in this solution

@qwertythefish6442 9 ай бұрын

This problem shouldn't be in the roadmap of bit manipulation.

@jasmeetsingh5425 2 жыл бұрын

I have a better logic guys: def reverse(self, x: int) -> int: if x>=0: val = int(str(x)[::-1]) return val if -2**31

@Ynno2 9 ай бұрын

This doesn't adhere to the 32-bit constraint.

@mdmuquimakhter5145 Жыл бұрын

nahi samajh aaya

@mehioahmad 2 жыл бұрын

I have implemented a different solution which for me was simpler to code and understand. I was simply undoing the last operation and checking if it gives me my previous result. for example if before reversing my last digit the result so far was 96463243, and the last digit to add was a 0 I would say: if (96463243*10/10 == 96463243) return 0; If after multiplying by 10 an overflow happens (which does in the example above) the entire integer will be different

@illu1na 9 ай бұрын

if res < MIN // 10 or (res == MIN // 10 and digit < MIN % 10): Why did you use // 10 and % 10 instead of fmod and int(/) trick? cos MIN % 10 would give you positive number. Let's say x = -2147483649 (below MIN) x % 10 would be 1 instead of -9 and MIN % 10 would be 3 instead of -7 OK + 10 still gives you the same inequalities.

@sumishajmani705 2 жыл бұрын

what is difference between "%" and "math.fmod" ? I was getting different answers for negative numbers by just using "%" operator.

@marcelofernandes3230 2 жыл бұрын

Python's mod operation (a % b) behaves like a clock of size b. So, if you do 11 % 10 you get 1, but if you do -1 % 10 you get 9, because you wrapped around from 0 to the largest value in [0, 9]. This is useful for traversing a circular array counter-clockwise, for example, but can cause some unexpected behavior, like in this problem. The fmod function behaves like you might expect, math.fmod(-1, 10) == -1.0. It returns a float so that's why NC casted it to int.

@yanggravity5876 2 жыл бұрын

isn't the check MIN outbound condition wrong? as MIN //10=-214748365, so with the video code never check if -214748364+last digit outbound. good method & explain tho.

@snoopyuj Жыл бұрын

My solution is just check "if (curRes / 10 != preRes) return 0"

@tarekshokry1366 2 жыл бұрын

How can the input be integer and be *8463847412* if it exceeds 2^31 ?

@jjayguy23 Жыл бұрын

The input x cannot be 8463847412, because the given constraints are a 32-bit integer in the range of -2^31

@Deescacha 7 ай бұрын

Solution that works: ``` class Solution: def reverse(self, x: int) -> int: result = 0 MAX_INT32 = 2 ** 31 - 1 # 2147483647 MIN_INT32 = -2 ** 31 # -2147483648 MAX_INT32_DIV_10 = int(MAX_INT32 / 10) MIN_INT32_DIV_10 = int(MIN_INT32 / 10) LAST_DIGIT_MAX_INT32 = MAX_INT32 % 10 LAST_DIGIT_MIN_INT32 = int(math.fmod(MIN_INT32, 10)) while x != 0: if result > MAX_INT32_DIV_10 or result < MIN_INT32_DIV_10: return 0 digit = int(math.fmod(x, 10)) x = int(x / 10) result = result * 10 + digit return result; ```

@jayshi3338 6 ай бұрын

Save yourself some time 1. This code does NOT work on LeetCode 2. There is no need to check if res == MAX // 10 for overflow, this case is covered by input itself.