吃过晚饭， 没啥事， 随手做了两道题， 都是easy 级别的， 在这也给大家伙看看。

7 整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

在下就喜欢做这种简单的题， 小手一挥， 就写出了几行代码：

/**
 * @param {number} x
 * @return {number}
 */
 var reverse = function(x) {
   var isPositive = x >= 0, result;
   var temp = isPositive ? x : -x
   var t2 = (temp + '').split('').reverse().join('') - 0;
   result = isPositive ? t2 : -t2
    if(result > 2147483647 || result < -2147483648 ) {
        return 0;
    } else {
        return result;
    }
 };

一提交， Beat 89.45%, 嘴角微微上扬 🙂

高兴不过三秒， 发现情况不对：

这一波字符串操作， 看起来很溜， 内存只存储得下一个32 位的有符号整数。
字符串的链式调用内部进行了至少三重循环, 这么下去肯定是不行的。得改：

var reverse = function(x) {
    var y = 0;
    if (x >= 0) {
        while (x > 0) {
            if (y > 214748364 || y === 214748364 && x % 10 > 7) {
                return 0
            }
            y = y * 10 + x % 10
            x = x / 10 | 0
        }
        return y
    } else {
        x = -x
        while (x > 0) {
            if (y > 214748364 || y === 214748364 && x % 10 > 8) {
                return 0
            }
            y = y * 10 + x % 10
            x = x / 10 | 0
        }
        return -y
    }
};

这样应该就可以了.

448. 找到所有数组中消失的数字

给定一个范围在 1 ≤ a[i] ≤ n (n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。

找到所有在 [1, n] 范围之间没有出现在数组中的数字。

您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗?

你可以假定返回的数组不算在额外空间内。

示例输入:
[4,3,2,7,8,2,3,1]

输出:
[5,6]

您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗?

不能， 不能惯着你，我就要用额外空间。

上来就是一顿暴力操作：

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var findDisappearedNumbers = function(nums) {
    
    var length = nums.length;
    
    // step1: 获得标准的数据范围， 比如输入的是[1,1]， 那对应的标准结果就是[1,2]
    var result = [...Array(length + 1).keys()]
    result.splice(0, 1); 

    // step2: 将出现的数字标记为 0  
    for(var i = 0 ; i < length; i++) {
        var current = nums[i]
        if(result[current - 1]) { 
            result[current - 1] = 0;  // 出现过就标记为 0
        }
    }
    
    // step3: 遍历result， 取出不为 0 的数字即为最终结果
    return result.filter(v => v !== 0)
    
};

回头再来看条件限制： 不使用额外空间且时间复杂度为O(n)

不是很好搞， 我先回去想想，做出来之后再提出来， 大家也可以留言讨论。