1, 题目

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:

  1. 输入: 123
  2. 输出: 321

示例 2:

  1. 输入: -123
  2. 输出: -321

示例 3:

  1. 输入: 120
  2. 输出: 21

注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2, 算法

1, 超出int范围比较

  1. 分析:
  2.         数字9位以内,肯定不溢出
  3. 第一步, 溢出情况,直接返回0
  4. 第二步, 不溢出,直接反转
  1. # scala 实现
  2. object Solution {
  3.     def reverse(x: Int): Int = {
  4.         if (x == Int.MinValue) {
  5.             return 0
  6.         }
  7.         val x_abs = scala.math.abs(x)
  8.         if (x_abs.toString.length == 10 && x_abs.toString.reverse > Int.MaxValue.toString) {
  9.             return 0
  10.         }
  11.         reverse_order(x_abs) * scala.math.signum(x)
  12.     }
  14.     def reverse_order(x: Int): Int = {
  15.         var a = x
  16.         val queue = scala.collection.mutable.Queue[Int]()
  17.         while (a != 0) {
  18.             queue.enqueue(a % 10)
  19.             a /= 10
  20.         }
  21.         var p = 0
  22.         while (queue.nonEmpty) {
  23.             p = p * 10 + queue.dequeue()
  24.         }
  25.         p
  26.     }
  27. }
#python 实现
class Solution:
    def reverse(self, x: int) -> int:
        if x < 0:
            x = - int(str(-x)[::-1])
        else:
            x = int(str(x)[::-1])

        if -0x80000000 <= x <= 0x7fffffff:
            pass
        else:
            x = 0
        return x

2, int 范围内

第一步,  9位数以内,直接反转
第二步, 10位数,求逆序后前9位和与个位,判断是否溢出

# scala实现
object Solution {
    def reverse(x: Int): Int = {
        if (x==Int.MinValue){
            return 0
        }
        val x_abs = scala.math.abs(x)
        if (x_abs.toString.length < 10) {
            return reverse_order(x_abs) * scala.math.signum(x)
        }
        val a = x_abs.toString.substring(0, 1).toInt
        val b = x_abs.toString.substring(1).reverse.toInt
        if (b > Int.MaxValue / 10) {
            0
        } else if (b == Int.MaxValue / 10 && a > 7) {
            0
        } else {
            (b * 10 + a) * scala.math.signum(x)
        }

    }

    def reverse_order(x: Int): Int = {
        var a = x
        val queue = scala.collection.mutable.Queue[Int]()
        while (a != 0) {
            queue.enqueue(a % 10)
            a /= 10
        }
        var p = 0
        while (queue.nonEmpty) {
            p = p * 10 + queue.dequeue()
        }
        p
    }

}