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 < 0 else diff

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

if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
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;
    return 0;
}