2025-08-19：好数字之和。用go语言，给定一个整数数组 nums 和一个整数 k。对于每个下标 i，若与它相距 k 的左

2025-08-19：好数字之和。用go语言，给定一个整数数组 nums 和一个整数 k。对于每个下标 i，若与它相距 k 的左边位置 i-k 和右边位置 i+k（若存在的话）上的元素都比 nums[i] 小，则称 nums[i] 为“好”元素；若这两个位置中有任意一个越界，则该位置的元素也被视为“好”的。求出数组中所有“好”元素之和并返回。

2 <= nums.length <= 100。

1 <= nums[i] <= 1000。

1 <= k <= floor(nums.length / 2)。

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

输出： 12。

解释： 好的数字包括 nums[1] = 3，nums[4] = 5 和 nums[5] = 4，因为它们严格大于下标 i - k 和 i + k 处的数字。

题目来自力扣3452。

分步描述过程：

1. 1. 初始化总和：首先，初始化一个变量 ans 为 0，用于累加所有“好”元素的和。
2. 2. 遍历数组：遍历数组 nums 中的每一个元素 nums[i]，其中 i 是当前元素的下标（从 0 开始）。
3. 3. 检查左边位置 i-k：
   • • 如果 i-k 越界（即 i < k），则左边视为“满足条件”（因为越界被视为“好”）。
   • • 如果 i-k 不越界（即 i >= k），则需要检查 nums[i] 是否严格大于 nums[i-k]。如果是，则左边满足条件；否则不满足。
4. 4. 检查右边位置 i+k：
   • • 如果 i+k 越界（即 i+k >= len(nums)），则右边视为“满足条件”（因为越界被视为“好”）。
   • • 如果 i+k 不越界（即 i+k < len(nums)），则需要检查 nums[i] 是否严格大于 nums[i+k]。如果是，则右边满足条件；否则不满足。
5. 5. 判断是否为“好”元素：
   • • 如果左边和右边都满足条件（即左边越界或 nums[i] > nums[i-k]，且右边越界或 nums[i] > nums[i+k]），则 nums[i] 是一个“好”元素。
   • • 将该“好”元素的值 nums[i] 累加到 ans 中。
6. 6. 返回结果：遍历完所有元素后，返回累加的结果 ans。

示例分析：

以输入 nums = [1,3,2,1,5,4] 和 k = 2 为例：

• • i=0（nums[0]=1）：
  • • i-k = -2（越界，左边满足）。
  • • i+k = 2（nums[2]=2，1 > 2 不成立，右边不满足）。
  • • 不是“好”元素。
• • i=1（nums[1]=3）：
  • • i-k = -1（越界，左边满足）。
  • • i+k = 3（nums[3]=1，3 > 1 成立，右边满足）。
  • • 是“好”元素，累加 3。
• • i=2（nums[2]=2）：
  • • i-k = 0（nums[0]=1，2 > 1 成立，左边满足）。
  • • i+k = 4（nums[4]=5，2 > 5 不成立，右边不满足）。
  • • 不是“好”元素。
• • i=3（nums[3]=1）：
  • • i-k = 1（nums[1]=3，1 > 3 不成立，左边不满足）。
  • • i+k = 5（nums[5]=4，1 > 4 不成立，右边不满足）。
  • • 不是“好”元素。
• • i=4（nums[4]=5）：
  • • i-k = 2（nums[2]=2，5 > 2 成立，左边满足）。
  • • i+k = 6（越界，右边满足）。
  • • 是“好”元素，累加 5。
• • i=5（nums[5]=4）：
  • • i-k = 3（nums[3]=1，4 > 1 成立，左边满足）。
  • • i+k = 7（越界，右边满足）。
  • • 是“好”元素，累加 4。
• • 最终累加结果：3 + 5 + 4 = 12。

时间复杂度：

• • 遍历数组一次，时间复杂度为 O(n)。
• • 对于每个元素，最多进行两次比较（左边和右边），每次比较是 O(1)。
• • 因此，总时间复杂度为 O(n)。

额外空间复杂度：

• • 只使用了常数级别的额外空间（如 ans 变量），不随输入规模变化。
• • 因此，额外空间复杂度为 O(1)。

总结：

• • 时间复杂度：O(n)。
• • 额外空间复杂度：O(1)。

Go完整代码如下：

.

package main

import (
    "fmt"
)

func sumOfGoodNumbers(nums []int, k int) (ans int) {
    for i, x := range nums {
        if (i < k || x > nums[i-k]) && (i+k >= len(nums) || x > nums[i+k]) {
            ans += x
        }
    }
    return
}

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

Python完整代码如下：

.

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

def sum_of_good_numbers(nums, k):
    ans = 0
    n = len(nums)
    for i, x in enumerate(nums):
        if (i < k or x > nums[i - k]) and (i + k >= n or x > nums[i + k]):
            ans += x
    return ans

if __name__ == "__main__":
    nums = [1, 3, 2, 1, 5, 4]
    k = 2
    result = sum_of_good_numbers(nums, k)
    print(result)