每日一练——整数反转、括号生成

整数反转：

要求：
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
方法很简单，但是要注意不要忽略负数的输入。
法一：python取巧的写法，将整形转换成字符串，利用字符串切片操作轻松实现反向。

    def reverse(self, x: int) -> int:
        str_x = str(abs(x))
        res = int(str_x[::-1])
        if x < 0:
            res = -res
        return res if -(1 << 31) < res < (1 << 31) - 1 else 0

其中涉及位的操作：

法二：
对结果赋值为0，对x进行取余运算，每次除以10，余数加到结果后。当商与余数都为0时，说明x以全部转换完毕。
具体实现如下：

def reverse(self, x: int) -> int:
        flag = 1 if x >= 0 else - 1 # 记录下当前x的符号
        x = abs(x)
        ans = 0
        quotient,remainder = divmod(x,10) #此处的divmod等价于quotient = x //10 ，remainder = x % 10 
        while quotient > 0 or remainder > 0:
            ans = ans * 10 + remainder
            quotient, remainder = divmod(quotient, 10)
        ans *= flag
        return ans if -(1<<31) < ans < (1<<31)-1 else 0

括号生成：

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
例：

法1：每次加入整个括号
我们可以在已有括号序列的每个间隔中加入同时带有左括号与右括号的一个完整括号。每个括号序列的间隔数等于其长度加一。
具体实现如下：

def generateParenthesis(self, n: int) -> List[str]:
        if n <= 0:
            return []
        res = set() #用集合存储结果，可去重
        for _ in range(n): # 需要添加n个括号，所以循环n次
            if len(res) == 0:
                res.add("()")
            else:
                tmp = set() #设置一个暂时的集合来存储新生成的括号序列
                for x in res: #遍历res，x为每一个不同的括号序列
                    for i in range(len(x) + 1): #在每一个间隔中加入（）并将新生成的序列存入tmp
                        tmp.add(x[:i] + "()" + x[i:])
                res = tmp
        return list(res)

简化后可得以下代码

def generateParenthesis(self, n: int) -> List[str]:
        if n <= 0:
            return []
        res = {"()",}
        for _ in (range(n - 1)):
            res = {x[:i] + "()" + x[i:] for x in res for i in range(len(x) + 1)}
        return list(res)

运行结果：

法二： 每次加入半个括号，利用dfs的思想
可以模拟每次只加半个括号的过程，第一个必须添加左括号，则得到“(”，下一个可以继续加入左括号，也可以加入右括号。如果下一个加入的是左括号，则得到“((”接下来可以连续加入两个右括号。以此类推可得到规律：
当左括号个数小于n时，可继续添加左括号，当右括号小于左括号数时，可继续添加右括号。
既然利用dfs，则就要考虑递归的basecase，很明显，此题的最终结束条件为递归深度等于2n。
递归的重要特性就是本层只管本层的事。递归的每一层只需要做一件事，：加左括号或者加右括号。
递归时需要输入的参数有：现有的括号序列，左括号数，右括号数，需生成括号数，递归深度。
最终代码如下：

def generate_parentheses(n):
    res = []
    sample = ""
    
    def generate_parentheses_helper(sample, depth, n, left_num, right_num):
    	if depth == 2 * n: # basecase
        	res.append(sample)
        	return
    	if left_num < n:
        	generate_parentheses_helper(sample + "(", depth + 1, n, left_num + 1, right_num)
    	if right_num < left_num:
        	generate_parentheses_helper(sample + ")", depth + 1, n, left_num, right_num + 1)
        	
    if n != 0:
        generate_parentheses_helper(sample, 0, n, 0, 0)
    return res

运行结果：

很明显，法1简单快捷，时间复杂度低。但法二可以锻炼写递归，写dfs的能力。