吃过晚饭，没啥事，随手做了两道题，都是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), 假定返回的数组不算在额外空间内

假定返回的数组不算在额外空间 这句很关键，思考了一下之后，有了如下代码：

var findDisappearedNumbers = function(nums) {
    var result = [];
    
    for(var i = 0; i < nums.length; i++) {
        var index = nums[i] > 0 ?  nums[i] : -nums[i];
        index -= 1;
        if(nums[index] > 0) {
            nums[index] = -nums[index]
        }
    }
    
    for(var i = 0; i < nums.length; i++) {
        var currentItem = nums[i];
        if(currentItem > 0) {
            result.push(i+1)
        }
    }
    
    return result
};

思路也很简答，把出现的数字当成下标（要减1），一遍循环之后。没有没处理到的元素都是大于0的，这些元素的index + 1 的值。即是我们需要的结果。

同桌看到我在做这个题之后，讨论了一下，给出了他的实现，也只置换的思想：

unc findDisappearedNumbers(nums []int) []int {
	temp := 0
	for index := range nums {
		temp = nums[index]

		if temp == 0 || temp-1 == index {
			continue
		}

		nums[index] = 0
		for temp != 0 && temp != nums[temp-1] {
			stash := nums[temp-1]
			nums[temp-1] = temp
			temp = stash
		}
	}
	result := make([]int, 0)
	for index, item := range nums {
		if item == 0 {
			result = append(result, index+1)
		}
	}
	return result
}

欢迎留言讨论。

以上 :)

LeetCode[7, 448] Javascript 解法

#7 整数反转

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