leetCode - 整数翻转

给你一个 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

提示：

-2^31 <= x <= 2^31 - 1

解法1：

function reverse(x: number): number {
    const max: number = Math.pow(2, 31) - 1, min: number = -max - 1
    let total: number = 0
    if (x > max || x < min) return 0
    const strArr = x.toString().split('')
    if (!parseInt(strArr[0])) {
        total = parseInt(strArr[0] + strArr.slice(1).reverse().join(''))
    } else {
        total = parseInt(strArr.reverse().join(''))
    }

    if (total > max || total < min) return 0
    return total
};

但是这个虽然能实现，但是leetcode这里考究的是算法，所以我们不能使用reverse这样的api，其它解法稍后更新

---

漂亮的分割线

---

继续更新：

function reverse(x: number): number {
    const max: number = Math.pow(2, 31) - 1, min: number = -max-1
    let strs: string = ''
    if (x > max || x < min) return 0
    const str:string = x.toString()
    for (let i:number = str.length - 1; i >= 0; i--) {
        if (!parseInt(str.charAt(i)) && parseInt(str.charAt(i)) !== 0) {
            strs = str.charAt(i) + strs
        } else {
            strs = strs + str.charAt(i)
        }
    }
    if (parseInt(strs) > max || parseInt(strs) < min) return 0
    return parseInt(strs)
};

换了一种思想，直接用for循环反向遍历。但是感觉还是不算什么算法

---

漂亮的分割线X2

---

参考了官方的解题思路

1. 先对x做余数运算，
2. 然后在对x做除以10取整运算，
3. 然后每次的result 都由初始的0反向做乘以10运算，
4. 然后加上每次得到的余数
5. 最后做判断是否溢出

function reverse(x: number): number {
    let result:number = 0
    while(x){
        const dight:number = x % 10
        x= (x / 10) >> 0
        result = result*10 + dight
        if (result < Math.pow(-2, 31) || result > Math.pow(2, 31) - 1) return 0
    }
    return result
};

ps:这里应该还有更优化的地方，就是考虑当首位大于7的时候，长度达到多少，其实就已经溢出了，这里算一下2的31次方，这样应该可以提前退出循环，应该又会少很多