2026-04-08：连接非零数字并乘以其数字和Ⅰ。用go语言，给定一个整数 n。 1.从 n 的十进制表示中依次取出所有“非零数字”，保持它们出现的先后次序，

2026-04-08：连接非零数字并乘以其数字和Ⅰ。用go语言，给定一个整数 n。

1.从 n 的十进制表示中依次取出所有“非零数字”，保持它们出现的先后次序，把这些数字首尾相接得到一个新整数 x；如果 n 里没有非零数字，则令 x = 0。

2.计算 x 的所有数字之和，记为 sum。

3.返回 x * sum 的结果。

0 <= n <= 1000000000。

输入： n = 10203004。

输出： 12340。

解释：

非零数字是 1、2、3 和 4。因此，x = 1234。

数字和为 sum = 1 + 2 + 3 + 4 = 10。

因此，答案是 x * sum = 1234 * 10 = 12340。

题目来自力扣3754。

代码执行过程分步详细描述

给定输入整数 n = 10203004，严格按照题目要求和代码逻辑，分步骤拆解执行过程：

第一步：初始化变量

函数 sumAndMultiply 接收参数 10203004 后，先初始化3个核心变量：

1. x = 0：用于拼接非零数字，最终得到新整数
2. sum = 0：用于累加非零数字的和
3. pow10 = 1：用于控制数字拼接的位数（个位、十位、百位...）

---

第二步：循环拆分数字（逐位处理整数n）

循环条件：n > 0，每次循环将 n 除以10，去掉最后一位，直到 n 变为0，从右到左逐位取出数字：

1. 第一次循环

   • 当前 n = 10203004，取最后一位：10203004 % 10 = 4（非零数字）
   • 拼接：x = 0 + 4×1 = 4
   • 求和：sum = 0 + 4 = 4
   • 位数进位：pow10 = 1×10 = 10
   • 更新n：n = 10203004 /10 = 1020300

2. 第二次循环

   • 当前 n = 1020300，取最后一位：1020300 %10 = 0（零数字，跳过所有操作）
   • 更新n：n = 1020300 /10 = 102030

3. 第三次循环

   • 当前 n = 102030，取最后一位：102030 %10 = 0（零数字，跳过）
   • 更新n：n = 102030 /10 = 10203

4. 第四次循环

   • 当前 n = 10203，取最后一位：10203 %10 = 3（非零数字）
   • 拼接：x = 4 + 3×10 = 34
   • 求和：sum = 4 +3 =7
   • 位数进位：pow10 =10×10=100
   • 更新n：n=10203/10=1020

5. 第五次循环

   • 当前 n=1020，取最后一位：1020%10=0（零数字，跳过）
   • 更新n：n=1020/10=102

6. 第六次循环

   • 当前 n=102，取最后一位：102%10=2（非零数字）
   • 拼接：x=34 +2×100=234
   • 求和：sum=7+2=9
   • 位数进位：pow10=100×10=1000
   • 更新n：n=102/10=10

7. 第七次循环

   • 当前 n=10，取最后一位：10%10=0（零数字，跳过）
   • 更新n：n=10/10=1

8. 第八次循环

   • 当前 n=1，取最后一位：1%10=1（非零数字）
   • 拼接：x=234 +1×1000=1234
   • 求和：sum=9+1=10
   • 位数进位：pow10=1000×10=10000
   • 更新n：n=1/10=0

---

第三步：循环结束，计算最终结果

1. 循环终止：此时 n=0，不满足循环条件，退出循环
2. 最终值：拼接后的新整数 x=1234，数字和 sum=10
3. 计算乘积：1234 × 10 = 12340
4. 返回结果：函数将 12340 返回到主函数

---

第四步：主函数输出结果

主函数接收结果 12340 并打印，最终输出：12340

---

复杂度分析

1. 时间复杂度

• 代码核心是逐位遍历整数n的每一位数字，循环执行的次数等于整数n的十进制位数
• 例如：n=10203004 是8位数，循环执行8次
• 整数n的最大值为10^9，最多只有10位数字，循环次数是常数级
• 结论：时间复杂度为 O(1)（常数时间复杂度）

2. 额外空间复杂度

• 代码中只定义了x、sum、pow10、d这几个固定数量的变量，没有使用数组、切片、map等动态数据结构
• 无论输入n是多少，占用的额外内存空间都是固定不变的
• 结论：额外空间复杂度为 O(1)（常数空间复杂度）

总结

1. 执行过程：逐位提取数字→过滤零→拼接非零数字→计算数字和→求乘积；
2. 时间复杂度：O(1)，仅遍历固定位数的数字；
3. 额外空间复杂度：O(1)，仅使用固定数量的变量。

Go完整代码如下：

package main

import (
	"fmt"
)

func sumAndMultiply(n int) int64 {
	x, sum, pow10 := 0, 0, 1
	for ; n > 0; n /= 10 {
		d := n % 10
		if d > 0 {
			x += d * pow10
			sum += d
			pow10 *= 10
		}
	}
	return int64(x) * int64(sum)
}

func main() {
	n := 10203004
	result := sumAndMultiply(n)
	fmt.Println(result)
}

Python完整代码如下：

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

def sum_and_multiply(n: int) -> int:
    x, sum_digits, pow10 = 0, 0, 1
    while n > 0:
        d = n % 10
        if d > 0:
            x += d * pow10
            sum_digits += d
            pow10 *= 10
        n //= 10
    return x * sum_digits


def main():
    n = 10203004
    result = sum_and_multiply(n)
    print(result)


if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>

long long sumAndMultiply(int n) {
    int x = 0, sum = 0, pow10 = 1;
    while (n > 0) {
        int d = n % 10;
        if (d > 0) {
            x += d * pow10;
            sum += d;
            pow10 *= 10;
        }
        n /= 10;
    }
    return static_cast<long long>(x) * sum;
}

int main() {
    int n = 10203004;
    long long result = sumAndMultiply(n);
    std::cout << result << std::endl;
    return 0;
}