2026-05-01：整数的镜像距离。用go语言，给定一个整数 n，请计算它与其数字倒序后的数之间的差的绝对值。 其中，倒序后的数是把 n 的每一

2026-05-01：整数的镜像距离。用go语言，给定一个整数 n，请计算它与其数字倒序后的数之间的差的绝对值。

其中，倒序后的数是把 n 的每一位数字反过来得到的新整数。

请返回这个绝对值结果。

1 <= n <= 1000000000。

输入： n = 25。

输出： 27。

解释：

reverse(25) = 52。

因此，答案为 abs(25 – 52) = 27。

题目来自力扣3783。

一、分步详细执行过程 第一步：程序入口启动

程序从main函数开始运行，这是Go语言程序的执行起点。

1. 定义变量n，并赋值为题目给定的输入值25。

2. 调用核心计算函数mirrorDistance(25)，把 25 作为参数传入，开始计算镜像距离。

第二步：执行 mirrorDistance 函数（计算镜像距离）

这个函数的作用是：求原数和反转数的差的绝对值，执行步骤：

1. 接收传入的参数：原数n = 25。

2. 调用reverse函数，传入 25，计算数字反转后的结果，等待函数返回反转值。

3. 拿到反转结果后，计算：原数 - 反转数。

4. 判断计算结果是否小于0：

• 如果小于0，取它的相反数（也就是绝对值）；

• 如果大于等于0，直接返回结果。

5. 将最终的绝对值返回给main函数。

第三步：执行 reverse 函数（数字反转核心）

这个函数的作用是：把整数的每一位数字倒序排列，生成新整数，以输入 25 为例，步骤：

1. 初始化一个结果变量res，赋值为0，用来存储反转后的数字。

2. 进入循环：循环条件是当前数字大于 0，只要数字没处理完就一直循环。

• 第一次循环（当前数字=25）：

1. 取数字的最后一位：25 对 10 取余，得到5；

2. 拼接反转数字：res = 0*10 + 5，res 变为5；

3. 去掉最后一位：25 除以 10（取整数），数字变为2。

• 第二次循环（当前数字=2）：

1. 取最后一位：2 对 10 取余，得到2；

2. 拼接反转数字：res = 5*10 + 2，res 变为52；

3. 去掉最后一位：2 除以 10，数字变为0。

3. 循环结束（数字变为0，不满足循环条件）。

4. 将最终的反转结果52返回给mirrorDistance函数。

第四步：回到 mirrorDistance 函数完成计算

1. 计算差值：原数 25 – 反转数 52 =-27；

2. 判断差值：-27 小于 0，因此取它的相反数27；

3. 将结果 27 返回给main函数。

第五步：main 函数输出结果

1. 接收mirrorDistance函数返回的结果 27；

2. 打印输出结果，最终控制台显示：27。

二、时间复杂度 & 额外空间复杂度分析 1. 总时间复杂度

时间复杂度取决于数字反转函数 reverse的循环次数：

• 循环执行的次数 = 整数n的数字位数（比如 25 是2位，循环2次；1234是4位，循环4次）。

• 假设整数n的位数为k，时间复杂度为O(k)。

• 题目限定n ≤ 1000000000，最大位数是10位，循环最多执行10次，属于常数级时间复杂度。

2. 总额外空间复杂度

程序运行过程中：

• 只创建了固定数量的变量（res、diff、n等）；

• 没有使用数组、切片、map等动态扩容的数据结构；

• 无论输入数字多大，占用的额外内存空间都是固定不变的。

因此总额外空间复杂度为：O(1)（常数级空间复杂度）。

总结

1. 完整流程：启动程序→传入数值→反转数字→计算差值→取绝对值→输出结果；

2. 时间复杂度：O(k)（k为数字的位数）；

3. 额外空间复杂度：O(1)。

Go完整代码如下：

package main

 import (
    "fmt"
)

 func reverse(n int)int {
    res := 0
    for n > 0 {
        res = res*10 + n%10
        n /= 10
    }
    return res
}

 func mirrorDistance(n int)int {
    diff := n - reverse(n)
    if diff < 0 {
        return -diff
    }
    return diff
}

 func main() {
    n := 25
    result := mirrorDistance(n)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 def reverse(n: int) -> int:
    res = 0
    while n > 0:
        res = res * 10 + n % 10
        n //= 10
    return res

 def mirror_distance(n: int) -> int:
    diff = n - reverse(n)
    return -diff if diff < 0else diff

 def main():
    n = 25
    result = mirror_distance(n)
    print(result)

 if __name__ == "__main__":
    main()

C++完整代码如下：

  

using namespace std;

 int reverse(int n) {
    int res = 0;
    while (n > 0) {
        res = res * 10 + n % 10;
        n /= 10;
    }
    return res;
}

 int mirrorDistance(int n) {
    int diff = n - reverse(n);
    if (diff < 0) {
        return -diff;
    }
    return diff;
}

 int main() {
    int n = 25;
    int result = mirrorDistance(n);
    cout << result << endl;
    return0;
}

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。 欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。