leetcode刷题
好好刷题
反转整数(easy)
$ 2^ {31} -1=2147483647 $
$ -2^{31} =-2147483648 $
数学方法
一般做法：取模运算
但是忽略了负数以及题目范围
上图中，绿色的是最大32位整数
第二排数字中，橘子的是5，它是大于上面同位置的4，这就意味着5后跟任何数字，都会比最大32为整数都大。
所以，我们到【最大数的1/10】时，就要开始判断了
如果某个数字大于 214748364那后面就不用再判断了，肯定溢出了。
如果某个数字等于 214748364呢，这对应到上图中第三、第四、第五排的数字，需要要跟最大数的末尾数字比较，如果这个数字比7还大，说明溢出了。
负数同理
class Solution {
public int reverse(int x) {
int res = 0;
while(x!=0) {
//每次取末尾数字
int tmp = x%10;
//判断是否 大于 最大32位整数
if (res>214748364 || (res==214748364 && tmp>7)) {
return 0;
}
//判断是否 小于 最小32位整数
if (res<-214748364 || (res==-214748364 && tmp<-8)) {
return 0;
}
res = res*10 + tmp;
x /= 10;
}
return res;
}
}
关键点：
1.判断整数的正负
2.判断反转后的整数是否溢出
切片反转
python的话可以直接转成字符串切片
class Solution:
def reverse(self, x: int) -> int:
#将整数的绝对值转换成字符串
s=str(abs(x))
#翻转字符串
s=s[::-1]
#如果输入整数是负数，增加负号
if x <0:
s ='-' + s
#转换为整数
result = int(s)
#判断是否溢出
if result>=-2**31 and result<=2**31-1:
return result
else:
return 0
还有大佬写的很丝滑
class Solution:
def reverse(self, x: int) -> int:
s = str(x)
if s[0] == '-':
x = int('-' + s[1:][::-1])
else:
x = int(s[::-1])
return x if -2147483648< x <2147483647 else 0
我们可以一次构建反转整数的一位数字。在这样做的时候，我们可以预先检查向原整数附加另一位数字是否会导致溢出。
反转整数的方法可以与反转字符串进行类比。
我们想重复 “弹出” x 的最后一位数字，并将它 “推入” 到 res 的后面。最后，res 将与 x 相反。
取模
def reverse_better(self, x: int) -> int:
y, res = abs(x), 0
# 则其数值范围为 [−2^31, 2^31 − 1]
boundry = (1<<31) -1 if x>0 else 1<<31
while y != 0:
res = res*10 +y%10
if res > boundry :
return 0
y //=10
return res if x >0 else -res
这里用移位来表示的边界$ 1<<31=2^{31} $
先将x进行abs，取绝对值，所以当x小于零的话边界就是1<<31，如果大于零就是(1<<31) -1，数字y>boundry就表示数字在范围外，这里的数字y其实就是x的取绝对值的数，所以可以这样表示，return的时候再把负号加上去
复习一下 python 的位运算符：
(a & b)
按位与运算符：参与运算的两个值，如果两个相应位都为 1，则该位的结果为 1，否则为 0 。
输出结果 12 ，二进制解释： 0000 1100
(a | b)
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
输出结果 61 ，二进制解释： 0011 1101
(a ^ b)
按位异或运算符：当两对应的二进位相异时，结果为 1
输出结果 49 ，二进制解释： 0011 0001
(~a )
按位取反运算符：对数据的每个二进制位取反，即把 1 变为 0，把 0 变为 1 。~x 类似于 -x-1
输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
a << 2
左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补 0。
输出结果 240 ，二进制解释： 1111 0000
a >> 2
右移动运算符：把 ">>" 左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
输出结果 15 ，二进制解释： 0000 1111
python 赋值运算符：
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符c %= a等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
栈思路
class Solution:
def reverse(self, x: int) -> int:
stack = [] # 创建一个中间栈
x = str(x)
for i in x:
if i != 0: # 消除0 将已转换的字符串压入栈
stack.append(i)
if stack[0] == '-': # 负号情况下 栈底为-号 将其删掉 补到栈顶
stack.pop(0)
stack.append('-')
s = int(''.join(stack[::-1])) # 栈反转正好是反转的数字
if s >= 2147483647 or s <= -2147483648: # 判断溢出情况
return 0
return s
罗马数字转整数(easy)
分析题目，只有在遇到特殊情况时，两个字符中左边的字符小于右边的字符，且等于右边的字符代表的数减左边字符代表的数。 比如 CM 等于 1000 - 1001000−100，XC 等于 100 - 10100−10...
其他情况就直接加就行了
那么我们只需要读取输入 遍历hashmap 判断是否需要减 就可以了
class Solution:
def romanToInt(self, s: str) -> int:
m = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
result = 0
for i in range(len(s)):
if i < len(s)-1 and m[s[i]] < m[s[i+1]]:
result -= m[s[i]]
else:
result += m[s[i]]
return result
最长公共前缀
python两种让你拍大腿的解法，时间复杂度你想象不到，短小精悍。
1、利用python的max()和min()，在Python里字符串是可以比较的，按照ascII值排，举例abb， aba，abac，最大为abb，最小为aba。所以只需要比较最大最小的公共前缀就是整个数组的公共前缀
def longestCommonPrefix(self, strs):
if not strs: return ""
s1 = min(strs)
s2 = max(strs)
for i,x in enumerate(s1):
if x != s2[i]:
return s2[:i]
return s1
2、利用python的zip函数，把str看成list然后把输入看成二维数组，左对齐纵向压缩，然后把每项利用集合去重，之后遍历list中找到元素长度大于1之前的就是公共前缀
def longestCommonPrefix(self, strs):
if not strs: return ""
ss = list(map(set, zip(*strs)))
res = ""
for i, x in enumerate(ss):
x = list(x)
if len(x) > 1:
break
res = res + x[0]
return res
