#6_力扣打卡第六天(7-8)

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

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

假设环境不允许存储 64 位整数（有符号或无符号）。
 

示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
 

int reverse(int x){
long n = 0;
	while (x)
	{
		n = n * 10 + x % 10;
		x /= 10;
	}
	return n > INT_MAX || n < INT_MIN ? 0 : n;
}

class Solution:
    def reverse(self, x: int) -> int:
        str_x=str(x)
        flag=0
        if '-' in str_x:
            str_x=str_x[1:]
            flag=1
        str_x=str_x[::-1]
        if flag==1:
            str_x='-'+str_x
        int_x=int(str_x)
        if -2**31<int_x<2**31-1:
            return int_x
        else:
            return 0

不过感觉都是用了超过64 位整数的环境空间，不符合题目的基本条件。

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。

函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−231,  231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
返回整数作为最终结果。
注意：

本题中的空白字符只包括空格字符 ' ' 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
 

示例 1：

输入：s = "42"
输出：42
解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
第 1 步："42"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："42"（读入 "42"）
           ^
解析得到整数 42 。
由于 "42" 在范围 [-231, 231 - 1] 内，最终结果为 42 。
示例 2：

输入：s = "   -42"
输出：-42
解释：
第 1 步："   -42"（读入前导空格，但忽视掉）
            ^
第 2 步："   -42"（读入 '-' 字符，所以结果应该是负数）
             ^
第 3 步："   -42"（读入 "42"）
               ^
解析得到整数 -42 。
由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42 。
示例 3：

输入：s = "4193 with words"
输出：4193
解释：
第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
             ^
解析得到整数 4193 。
由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193 。
示例 4：

输入：s = "words and 987"
输出：0
解释：
第 1 步："words and 987"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："words and 987"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
         ^
第 3 步："words and 987"（由于当前字符 'w' 不是一个数字，所以读入停止）
         ^
解析得到整数 0 ，因为没有读入任何数字。
由于 0 在范围 [-231, 231 - 1] 内，最终结果为 0 。
示例 5：

输入：s = "-91283472332"
输出：-2147483648
解释：
第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格）
         ^
第 2 步："-91283472332"（读入 '-' 字符，所以结果应该是负数）
          ^
第 3 步："-91283472332"（读入 "91283472332"）
                     ^
解析得到整数 -91283472332 。
由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/string-to-integer-atoi
 

思路：

将前面的‘ ’空白符号排除后，再排除‘0’符号，再分各种情况讨论，快把我逼疯了属于是。

class Solution:
    def myAtoi(self, s: str) -> int:
        if len(s)==0:
            return 0
        flag=1#设置循环条件
        zflag=0#判断转换字符的正负
        p=0#充当指针
        in_s=0
        while flag!=0:
            while s[p]==' ':   #将指针移动到负号或数字位或字母位
                p+=1
                if p==len(s):
                    return 0
            if p>=len(s):
                return 0
            if p+1==len(s):#排除单字符
                if '0'<=s[p]<='9':
                    return ord(s[p])-ord('0')
                else:
                    return 0
            if ('0'<=s[p+1]<='9'and(s[p]=='-'or s[p]=='+'))or '0'<=s[p]<='9':#前为字符后为符号
                if s[p]=='-':                 
                    zflag=1#判断正负
                    p=p+1
                if s[p]=='+':
                    zflag=0#判断正负
                    p=p+1
                if p==len(s):
                    return 0
                while s[p]=='0':#排除前面的0
                    p+=1
                    if p==len(s):
                        return 0
                if p>=len(s):
                    return 0  
                if not('0'<s[p]<='9'):#排除0后面不跟数字
                    return 0        
                in_s=ord(s[p])-ord('0')
                l=len(s)
                while  p+1<l  and '0' <= s[p + 1]<= '9'   :
                    in_s=in_s*10+ord(s[p+1])-ord('0')
                    p=p+1
            flag=0
        if zflag==1:
            in_s=-in_s
        if -2**31<=in_s<=2**31-1:
            return in_s
        elif in_s<-2**31:
            return -2**31
        elif in_s>2**31-1:
            return 2**31-1
        else:
            return 0
                 

            
            
                  

难点：
这道题难就难在调bug。

 光调bug就调了两页

所幸最后调了出来，真是喜极而泣啊！

只能说，能经历过考验的代码真是太让人佩服了。