2026-05-01：整數的鏡像距離。用go語言，給定一個整數 n，請計算它與其數字倒序后的數之間的差的絕對值。

其中，倒序后的數是把 n 的每一位數字反過來得到的新整數。

請返回這個絕對值結果。

1 <= n <= 1000000000。

輸入： n = 25。

輸出： 27。

解釋：

reverse(25) = 52。

因此，答案為 abs(25 - 52) = 27。

題目來自力扣3783。

一、分步詳細執行過程 第一步：程序入口啟動

程序從main函數開始運行，這是Go語言程序的執行起點。

1. 1. 定義變量n，并賦值為題目給定的輸入值25。

2. 2. 調用核心計算函數mirrorDistance(25)，把 25 作為參數傳入，開始計算鏡像距離。

這個函數的作用是：求原數和反轉數的差的絕對值，執行步驟：

1. 1. 接收傳入的參數：原數n = 25。

2. 2. 調用reverse函數，傳入 25，計算數字反轉后的結果，等待函數返回反轉值。

3. 3. 拿到反轉結果后，計算：原數 - 反轉數。

4. 4. 判斷計算結果是否小于0：

• ? 如果小于0，取它的相反數（也就是絕對值）；

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

5. 將最終的絕對值返回給main函數。

第三步：執行 reverse 函數（數字反轉核心）

這個函數的作用是：把整數的每一位數字倒序排列，生成新整數，以輸入 25 為例，步驟：

1. 1. 初始化一個結果變量res，賦值為0，用來存儲反轉后的數字。

2. 2. 進入循環：循環條件是當前數字大于 0，只要數字沒處理完就一直循環。

• ? 第一次循環（當前數字=25）：

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

2. 2. 拼接反轉數字：res = 0*10 + 5，res 變為5；

3. 3. 去掉最后一位：25 除以 10（取整數），數字變為2。

? 第二次循環（當前數字=2）：

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

2. 2. 拼接反轉數字：res = 5*10 + 2，res 變為52；

3. 3. 去掉最后一位：2 除以 10，數字變為0。

3. 循環結束（數字變為0，不滿足循環條件）。

4. 將最終的反轉結果52返回給mirrorDistance函數。

第四步：回到 mirrorDistance 函數完成計算

1. 1. 計算差值：原數 25 - 反轉數 52 =-27；

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

3. 3. 將結果 27 返回給main函數。

1. 1. 接收mirrorDistance函數返回的結果 27；

2. 2. 打印輸出結果，最終控制臺顯示：27。

時間復雜度取決于數字反轉函數 reverse的循環次數：

• ? 循環執行的次數 = 整數n的數字位數（比如 25 是2位，循環2次；1234是4位，循環4次）。

• ? 假設整數n的位數為k，時間復雜度為O(k)。

• ? 題目限定n ≤ 1000000000，最大位數是10位，循環最多執行10次，屬于常數級時間復雜度。

程序運行過程中：

• ? 只創建了固定數量的變量（res、diff、n等）；

• ? 沒有使用數組、切片、map等動態擴容的數據結構；

• ? 無論輸入數字多大，占用的額外內存空間都是固定不變的。

因此總額外空間復雜度為：O(1)（常數級空間復雜度）。

總結

1. 1. 完整流程：啟動程序→傳入數值→反轉數字→計算差值→取絕對值→輸出結果；

2. 2. 時間復雜度：O(k)（k為數字的位數）；

3. 3. 額外空間復雜度：O(1)。

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助力您的未來發展。