2026-02-24：计算十进制表示。用go语言，给定一个正整数 n。把能写成 d×10^k（其中 d 是 1 到 9 的整数，k 是非负整数）的正整数称为“十位分量”——等价于十进制表示里只有一位非零数字。例如 500、30、7 符合这一形式，而 537、102、11 不符合。

要求把 n 拆成若干个这样的十位分量之和，且所用分量的数量尽可能少。输出这些分量组成的数组，并按数值从大到小排序。

1 <= n <= 1000000000。

输入：n = 537。

输出：[500,30,7]。

解释：

我们可以将 537 表示为500 + 30 + 7。无法用少于 3 个 10 进制分量表示 537。

题目来自力扣3697。

一、整体解题思路分步解析

我们以输入 n = 537 为例，逐步拆解代码的执行逻辑，核心目标是把数字拆成最少的“十位分量”（仅一位非零的数）并降序排列：

步骤1：初始化关键变量

函数 decimalRepresentation 接收参数 n = 537 后，首先做两件事：

• 定义返回值 ans（切片类型），用于存储最终的十位分量；
• 定义变量 pow10 并初始化为 1，这个变量用于计算当前位的“位权”（即 10^k，k从0开始，对应个位、十位、百位等）。

步骤2：循环拆解每一位数字（核心逻辑）

进入 for 循环，循环条件是 n > 0，每次循环会完成“取当前最低位→判断是否有效→计算十位分量→更新n和位权”的操作，具体过程如下：

注：循环中“d>0”的判断是为了跳过数字中的0位（比如n=507时，十位的0会被跳过，不会生成0×10=0这样的无效分量）。

步骤3：反转切片实现降序排序

循环结束后，ans切片中的元素是 [7, 30, 500]，而题目要求按数值从大到小排序，因此调用 slices.Reverse(ans) 反转切片，得到 [500, 30, 7]。

步骤4：返回结果并输出

函数返回处理后的ans切片，main函数接收结果后打印，最终输出 [500 30 7]，符合题目要求。

二、时间复杂度与空间复杂度分析

1. 时间复杂度

• 循环次数：取决于输入n的十进制位数，设n的位数为k（比如537是3位，k=3；1000000000是10位，k=10），循环会执行k次，时间复杂度为O(k)；
• 反转切片：slices.Reverse 是原地反转，时间复杂度为O(k)（k为切片长度，等于n的非零位数，最多等于k）；
• 总时间复杂度：O(k) + O(k) = O(k)。由于n的范围是1≤n≤10^9，k最大为10（固定常数），因此实际时间复杂度为O(1)（常数时间）。

2. 额外空间复杂度

• 变量开销：pow10、d、n（函数内的副本）等都是单个整型变量，空间开销为O(1)；
• 切片ans：存储的元素数量等于n的非零位数（比如537有3个非零位，ans长度为3；n=507有2个非零位，ans长度为2），最多为10个元素（n=10^9时是1个元素），因此切片的额外空间开销为O(k)；
• 总额外空间复杂度：O(1) + O(k) = O(k)，同样因为k最大为10（固定常数），实际额外空间复杂度为O(1)（常数空间）。

总结

1. 核心过程：先逐位拆解数字，提取非零位并计算对应的十位分量，再反转切片实现降序，最终得到最少数量的十位分量数组；
2. 时间复杂度：O(1)（因n的位数最多10位，属于常数级）；
3. 额外空间复杂度：O(1)（存储结果的切片长度最多10，无额外冗余空间）。

Go完整代码如下：

package main

import (
	"fmt"
	"slices"
)

func decimalRepresentation(n int) (ans []int) {
	pow10 := 1
	for ; n > 0; n /= 10 {
		d := n % 10
		if d > 0 {
			ans = append(ans, d*pow10)
		}
		pow10 *= 10
	}
	slices.Reverse(ans)
	return
}

func main() {
	n := 537
	result := decimalRepresentation(n)
	fmt.Println(result)
}

Python完整代码如下：

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

def decimal_representation(n: int) -> list[int]:
    """
    将整数拆分为十进制位值表示
    
    例如: 537 -> [500, 30, 7]
    """
    ans = []
    pow10 = 1
    
    while n > 0:
        d = n % 10  # 获取最后一位数字
        if d > 0:
            ans.append(d * pow10)
        n //= 10    # 去掉最后一位
        pow10 *= 10
    
    ans.reverse()
    return ans

if __name__ == "__main__":
    n = 537
    result = decimal_representation(n)
    print(result)

C++完整代码如下：

#include <iostream>
#include <vector>
#include <algorithm>

std::vector<int> decimalRepresentation(int n) {
    std::vector<int> ans;
    int pow10 = 1;

    while (n > 0) {
        int d = n % 10;  // 获取最后一位数字
        if (d > 0) {
            ans.push_back(d * pow10);
        }
        n /= 10;         // 去掉最后一位
        pow10 *= 10;
    }

    std::reverse(ans.begin(), ans.end());
    return ans;
}

int main() {
    int n = 537;
    std::vector<int> result = decimalRepresentation(n);

    // 打印结果
    std::cout << "[";
    for (size_t i = 0; i < result.size(); ++i) {
        std::cout << result[i];
        if (i < result.size() - 1) {
            std::cout << ", ";
        }
    }
    std::cout << "]" << std::endl;

    return 0;
}