a0007.md

7. Reverse Integer

Description

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output: 321

Example 2:

Input: -123
Output: -321

Example 3:

Input: 120
Output: 21

Note:

Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−231, 231 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

分析和方案

题目为反转数字上的每一位，结果中为零的最高位消除，并且对输入数字有位数限制。

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    var minn = - (1 << 30) * 2;
    var maxn = (1 << 30) * 2 - 1;
    var ans;
    var arr = x.toString().split('');
    if (x < 0) {
      arr.shift();  // remove '-'
    }
    ans = Number(arr.reverse().join(''));
    if (x < 0){
      ans *= -1;
    }
    if (ans < minn || ans > maxn){
      return 0;
    }else{
      return ans;
    }
    
};

思路就是把数字转为字符，然后按位拆开，再反向合并字符串，强转换为数字时最高位的零会自动去掉。最后判断一下原数的正负，做一下对应处理。

最快

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    var n = x > 0;
    var result = 0;
    while (x != 0) {
        result = result * 10 + x % 10;
        x = parseInt(x / 10);
    }
    
    result = Math.abs(result);
    
    return result > Math.pow(2, 31) ? 0 : n ? result : -result;
};

这个是性能最好的解法，用一次while遍历，把x按位把值取到result中，最后输出的时候，利用双层二元运算，嵌套判断数字长度和正负

第二

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    var xString = x.toString();
    var neg = false;
    if (xString.charAt(0) == '-') {
        neg = true;
        xString = xString.substr(1);
    }
    var revString = '';
    for (var i=(xString.length-1); i>=0; i--) {
        revString += xString.charAt(i);
    }
    if (neg) {
        revString = '-' + revString;
    }
    var revInt = parseInt(revString);
    if (isNaN(revInt)) {return 0;}
    else if (revInt > 2147483647 || revInt < -2147483648) {return 0;}
    else {return revInt;}
};

这个方案，还是转字符串的方式，在操作中使用charAt，parseInt优化了性能，判断边界数据时，用了写死边界值，也提高了性能

第三

/**
 * @param {number} x
 * @return {number}
 */
var reverse = function(x) {
    let b = x;
    if (x < 0) {
        b = Math.abs(x);
    }
    
    let c = (x < 0 ? "-" : "") + b.toString().split("").reverse().join("");
    
    let min = Math.pow(-2, 31);
    let max = Math.pow(2, 31) - 1;
    
    return (min < +c && c < max) ? +c : 0 ;
};

和最初的方案类似，在操作整，有不少优化点