[PYTHON] Let Code Day 61 "7. Reverse Integer" starting from zero

Overview

It seems that coding tests are conducted overseas in interviews with engineers, and in many cases, the main thing is to implement specific functions and classes according to the theme.

Apparently, many engineers take measures on the site called LetCode.

It is a site that trains the algorithmic power that can withstand the coding test that is being done in the early story, and it is an inevitable path for those who want to build a career at an overseas tech company.

I wrote it in a big way, but I have no plans to have such an interview at the moment.

However, as an IT engineer, it would be better to have the same level of algorithm power as a person, so I would like to solve the problem irregularly and write down the method I thought at that time as a memo.

Leetcode

I'm solving it with Python3.

Leet Code Table of Contents Starting from Zero

Last time Leet Code Day 60 starting from zero "1481. Least Number of Unique Integers after K Removals"

Right now, I'm prioritizing the Medium of the Top 100 Liked Questions. I solved all Easy, so if you are interested, please go to the table of contents.

Twitter I'm doing it.

problem

7. Reverse Integer

The difficulty level is Easy. Given the 32-bit signed integer x, the problem is to design an algorithm that computes the reciprocal of the integer.

Input: 123 Output: 321

Input: -123 Output: -321

Input: 120 Output: 21

solution

In the case of Python, if you use slices and ʻabs`, you can specify elements and manage absolute values, so I think it is relatively easy to solve.

I don't know about other languages, but it may be common to solve using the stack.

Since it is assumed that it is a 32-bit integer this time, it is better to check in advance whether it will overflow even if another digit is added before starting processing.

In Python, there is no maximum value for int type, so you can calculate as much as you have memory. So you need to set it yourself as follows.

max_32 = 2**31 - 1

If x is larger than this value at the beginning, it will be properly classified when 0 is returned unconditionally.

And for the branch after this, if it is a positive value, it will pick up the element from the back, and if it is a negative value, it will pick up the element from the opposite of the absolute value and add - before substituting it. ..

In Python, if the value is negative, if you add - to the beginning of the element to be assigned, it will be in the state with - even after re-inversion.

Isn't it okay to write the inverted version in a comprehension? You may think that, but there is still the possibility of overflow if the process is completed with this alone.

So, if it seems to overflow to the last branch, 0 is returned, and in other cases, the inverted value is returned, and it is completed.

The following is a summary of these series of steps.

class Solution:
    def reverse(self, x: int) -> int:
        max_32 = 2**31 - 1
        if abs(x) > max_32:
            return 0
        if x < 0:
            reverse_int = -int(str(abs(x))[::-1])
        else:
            reverse_int = int(str(x)[::-1])
        if abs(reverse_int) > max_32:
            return 0
        else:
            return reverse_int
# Runtime: 28 ms, faster than 86.13% of Python3 online submissions for Reverse Integer.
# Memory Usage: 14 MB, less than 9.77% of Python3 online submissions for Reverse Integer.

By the way, I started a new blog. We plan to continue sending information on Qiita, but if you are interested, please use the profile as it will be written like a gadget blog with technology that allows you to write in a relaxed manner.

Up to here for this time. Thank you for your hard work.