自用力扣刷题记录（Python，数与位、栈与递归）

顺序参考：https://leetcode-cn.com/circle/article/48kq9d/

三、数与位

题目分类	题目编号
数字的位操作	7、9、 479、564、231、342、326、504、263、190、191、476、461、477、693、393、172、 458、 258、 319、405、171、168 、670、233 、357、400
简单数学题	492、~~ 29、507~~
快速幂	50、372

7 整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

class Solution:
    def reverse(self, x: int) -> int:
        lis= []
        result = 0
        if x < 0:
            isf = 1
            x = -x
        else:
            isf = 0
        while x !=0:
            lis.append(int(x%10))
            x = int(x/10)
        for i in range(len(lis)):
            result += lis[i]*(10**(len(lis)-i-1))
        if isf == 1:
            if -result<-2**31:
                return 0
            else:
                return -result
        else:
            if result > 2**31-1:
                return 0
            else:
                return result

9. 回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x <0:
            return False
        if x < 10:
            return True
        lis = []
        while x !=0:
            lis.append(int(x%10))
            x = int(x/10)
        for i in range(int(len(lis)/2+1)):
            if lis[i]!=lis[len(lis)-i-1]:
                return False
        return True

564 寻找最近的回文数

给定一个整数 n ，你需要找到与它最近的回文数（不包括自身）。

“最近的”定义为两个整数差的绝对值最小。

不想努力了，大佬的代码：

class Solution:
    def nearestPalindromic(self, n: str) -> str:
        length, int_n = len(n), int(n)
        if int_n < 10 or int_n == 10 ** (length-1): return str(int_n-1) # 1-10以及1000这类情况
        if int_n - 1 == 10 ** (length-1): return str(int_n-2)#1001类
        if int_n + 1 == 10 ** length: return str(int_n + 2)#999类
		#奇偶处理，取n的前一半
        pre = int(n[:(length+1)//2])
        #前一半+1 -1后拼起来
        tmp = [s[:length//2] + s[::-1] for s in [str(pre + dx) for dx in (-1, 0, 1)]]
        return min(tmp, key=lambda x: (x==n, abs(int(x)-int_n)))#作比较

231. 2 的幂

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

class Solution:
    def isPowerOfTwo(self, n: int) -> bool:
        if n <=0 :#小于0的都不是
            return False
        a = bin(n)
        a = a[2:]#转为二进制后一定是1开头后面跟着0
        if int(a[::-1]) == 1:
            return True
        else:
            return False

342. 4的幂

给定一个整数，写一个函数来判断它是否是 4 的幂次方。如果是，返回 true ；否则，返回 false 。

class Solution:
    def isPowerOfFour(self, n: int) -> bool:
        if n <=0 :#小于0的都不是
            return False
        a = bin(n)
        a = a[2:]#转为二进制后一定是1开头后面跟着0,且长度为奇数（偶数的为2的幂）
        if int(a[::-1]) == 1 and len(a)%2 == 1:
            return True
        else:
            return False

326. 3的幂

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        if n <= 0:
            return False
        flag = True
        while n != 1:
            if n%3 != 0:
                flag = False
                break
            else:
                n /= 3
        return flag

504. 七进制数

class Solution:
    def convertToBase7(self, num: int) -> str:
        ans = ''
        if num>=0:
            f = ''
        else:
            f = '-'
            num = abs(num)
        while num >= 7:
            s = str(num%7)
            ans += s
            num //= 7
        ans += str(num)
        return f+ans[::-1]

263. 丑数

给你一个整数 n ，请你判断 n 是否为 丑数 。如果是，返回 true ；否则，返回 false 。

丑数 就是只包含质因数 2、3 和/或 5 的正整数。

class Solution:
    def isUgly(self, n: int) -> bool:
        while n > 1:
            if n%2 != 0:
                break
            else:
                n /= 2
        while n > 1:
            if n%3 != 0:
                break
            else:
                n /= 3
        while n > 1:
            if n%5 != 0:
                break
            else:
                n /= 5
        if n == 1:
            return True
        else:
            return False

190. 颠倒二进制位

颠倒给定的 32 位无符号整数的二进制位。
输入输出就写了老半天

class Solution:
    def reverseBits(self, n: int) -> int:
    # n进来之后是个十进制，先转为二进制，在前面补0补成32位，颠倒过来，再转换为十进制返回
        return int("0b"+("0"*32+bin(n)[2:])[-32:][::-1], base=2)

191. 位1的个数

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

class Solution:
    def hammingWeight(self, n: int) -> int:
        a = bin(n)
        ans = a.count('1')
        return ans

476. 数字的补数

给你一个 正 整数 num ，输出它的补数。补数是对该数的二进制表示取反。

class Solution:
    def findComplement(self, num: int) -> int:
        t = bin(num)[2:]
        ans = ''
        for i in t:
            if i