2025-04-28：替换为数位和以后的最小元素。用go语言，给定一个整数数组 nums，你需要将数组中每个元素替换成该元素各位数字之和。

完成替换后，请返回数组中的最小值。

1 <= nums.length <= 100。

1 <= nums[i] <= 10000。

输入：nums = [999,19,199]。

输出：10。

解释：

nums 替换后变为 [27, 10, 19] ，最小元素为 10 。

题目来自leetcode3300。

详细步骤：

1. 输入准备

   • 接收一个整数数组 nums，数组长度为 1 到 100 之间，数组中每个元素的范围是 1 到 10000。

2. 初始化变量

   • 定义一个变量 minV 用来记录当前计算出的数位和中的最小值。
   • 将 minV 初始化为一个很大的整数值（比如系统支持的最大整数），确保后面比较时可以更新。

3. 遍历数组元素

   • 依次访问数组中的每一个元素 num。

4. 计算数位和

   • 对当前元素 num，计算其各个位数的数字和。例如，对于 999：
     • 取最后一位数字 9 累加，
     • 再取倒数第二位数字 9 累加，
     • 取倒数第三位数字 9 累加，
     • 结果为 27。
   • 具体做法是通过不断对数字取模 10 (num % 10) 获取个位数，再通过整除 10 (num / 10) 去除最低位，直到数字被处理完。

5. 更新最小值

   • 用刚计算得到的数位和与当前 minV 进行比较。
   • 如果该数位和更小，则将其更新为新的 minV。

6. 完成遍历

   • 重复步骤 3-5，直到所有元素都完成数位和的计算并比较。

7. 返回结果

   • 返回最终得到的最小数位和 minV。

8. 补充说明

   • 题目中提到“将数组中每个元素替换成各位数字之和”，代码虽然没有将数组元素实际修改，但计算过程模拟了替换后的数值计算，最终得到的最小值即为替换后数组中的最小元素。

总时间复杂度分析：

• 对于数组中每个元素，都需要计算其数位和。
• 每个元素最多有 4 位数字（因为最大值是 10000），
• 计算一个元素的数位和是 O(位数)，即 O(4) = O(1)（常数时间）。
• 数组长度最多为 100。
• 因此，遍历整个数组的时间复杂度是 O(n)，其中 n 是数组长度。

总体时间复杂度为 O(n)。

总额外空间复杂度分析：

• 代码中没有使用额外的数组或大规模的数据结构。
• 只使用了若干整型变量用于临时存储和比较（如 cur、minV）等。
• 因此，额外空间复杂度为 O(1)，即常数空间。

Go完整代码如下：

package main

import (
	"fmt"
	"math"
)

func minElement(nums []int) int {
	minV := math.MaxInt64
	for _, num := range nums {
		cur := 0
		// 计算当前数字的各个位数之和
		for n := num; n > 0; n /= 10 {
			cur += n % 10
		}
		if cur < minV {
			minV = cur
		}
	}
	return minV
}

func main() {
	nums := []int{999, 19, 199}
	result := minElement(nums)
	fmt.Println(result)
}

Python完整代码如下：

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

def min_element(nums):
    min_v = float('inf')
    for num in nums:
        cur = 0
        n = num
        while n > 0:
            cur += n % 10
            n //= 10
        if cur < min_v:
            min_v = cur
    return min_v

if __name__ == "__main__":
    nums = [999, 19, 199]
    result = min_element(nums)
    print(result)