2025-11-01：数位和等于下标的最小下标。用go语言，给定一个整数数组 nums，找出最小的索引 i（索引从 0 开始），使得把 nums[i] 按位拆分

2025-11-01：数位和等于下标的最小下标。用go语言，给定一个整数数组 nums，找出最小的索引 i（索引从 0 开始），使得把 nums[i] 按位拆分后各位数字相加得到的和等于 i。如果不存在这样的索引，则返回 -1。

1 <= nums.length <= 100。

0 <= nums[i] <= 1000。

输入：nums = [1,3,2]。

输出：2。

解释：

nums[2] = 2，其数位和等于 2 ，与其下标 i = 2 相等。因此，输出为 2 。

题目来自力扣3550。

分步骤描述过程

初始化阶段：
- 函数接收一个整数数组 nums 作为输入
- 准备遍历数组中的元素，从索引 0 开始
遍历限制：
- 只遍历数组的前 min(len(nums), 28) 个元素
- 这意味着最多只检查前 28 个元素，即使数组长度超过 28
- 对于示例 [1,3,2]，数组长度为 3，所以会检查所有 3 个元素
逐个元素处理：
- 对于每个索引 i 和对应的元素 x：
  - 计算数位和：
    - 初始化求和变量 s = 0
    - 通过循环将 x 反复除以 10，每次取余数得到最低位数字
    - 将每位数字累加到 s 中
    - 例如：对于数字 123，计算过程：123%10=3 → s=3，12%10=2 → s=5，1%10=1 → s=6
  - 条件检查：
    - 比较数位和 s 与当前索引 i
    - 如果相等，立即返回当前索引 i 作为结果
终止条件：
- 如果在前 28 个元素中找到满足条件的索引，立即返回该索引
- 如果遍历完前 28 个元素仍未找到满足条件的索引，返回 -1
示例执行过程（nums = [1,3,2]）：
- i=0, x=1：数位和=1，1≠0，继续
- i=1, x=3：数位和=3，3≠1，继续
- i=2, x=2：数位和=2，2=2，匹配成功，返回 2

复杂度分析

总的时间复杂度：O(1)

由于最多只检查 28 个元素，且每个数字的数位和计算最多需要 O(d) 时间（d 是数字的位数）
由于数字最大为 1000（最多 4 位数），且检查的元素数量固定为 28，因此总时间是常数级别的

总的额外空间复杂度：O(1)

只使用了固定数量的变量（i, x, s），不随输入规模增长
没有使用额外的数据结构或递归调用

Go完整代码如下：

package main

import (
	"fmt"
)

func smallestIndex(nums []int) int {
	for i, x := range nums[:min(len(nums), 28)] {
		s := 0
		for ; x > 0; x /= 10 {
			s += x % 10
		}
		if s == i {
			return i
		}
	}
	return -1
}

func main() {
	nums := []int{1, 3, 2}
	result := smallestIndex(nums)
	fmt.Println(result)
}

在这里插入图片描述

Python完整代码如下：

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

def smallest_index(nums):
    for i in range(min(len(nums), 28)):
        x = nums[i]
        s = 0
        while x > 0:
            s += x % 10
            x //= 10
        if s == i:
            return i
    return -1

if __name__ == "__main__":
    nums = [1, 3, 2]
    result = smallest_index(nums)
    print(result)

在这里插入图片描述