---
# System prepended metadata

title: 整数反转
tags: [LeeCode]

---

# 整数反转
---

```javascript=
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321

示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21

注意:

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

:::success
```go=
// 使用的go的int to string

func reverse(x int) int {
	symbol, result := intToSting(x) // 1.int to string

	rsp, err := strconv.Atoi(result) // 2. string to int
	if err != nil {
		return -1
	}

	if symbol { // 正数同时保证不溢出
		if rsp > math.MaxInt32 {
			return 0
		}
		return rsp
	} else { // 负数同时保证不溢出
		if rsp * -1 < math.MinInt32 {
			return 0
		}
		return rsp * -1
	}
}

func intToSting(s int) (bool, string) { // int to sting 同时区分正负数字
	result := strconv.Itoa(s)

	if s >= 0 { // 正数
		return true, reverseString(result)
	} else { // 负数
		return false, reverseString(strings.Split(result, "-")[1])
	}
}

func reverseString(s string) string { // 字符串反转
	result := []byte(s)
	for i, j := 0, len(s) - 1; i < j; i, j = i + 1, j - 1 {
		result[i], result[j] = result[j], result[i]
	}
	return string(result)
}


// 采用 % 10 取余 和 / 10 取商的方法

/*
123

循环条件是每次是否除10已除尽，除尽就终止循环

第一轮 ：
123 % 10 = 3
123 / 10 = 12
此时得到的是逆向数字最高位，保存的结果是3，还需继续计算的是12

第二轮 ：

12 % 10 = 2
12 / 10 = 1

此时得到的是逆向数字第二高位2， 最终保存的结果是3 * 10 + 2 = 32，还需继续计算的是1

第二轮 ：

1 % 10 = 2
1 / 10 = 0 // 此时已除尽

此时得到的是逆向数字最后一位， 最终保存的结果是32 * 10 + 1= 321
 */

func reverse(x int) int {
	result := reverseInt(x)

	if result > 0 && result > math.MaxInt32 || result < 0 && result < math.MinInt32 {
		return 0
	}

	return result
}

func reverseInt(i int) int {
	result := 0

	for i != 0 {
		mod := i % 10
		result = result * 10 + mod
		i /= 10
	}

	return result
}
```
:::

###### tags: `LeeCode`