2025-06-26：转换数组。用go语言，给你一个整数数组 nums，它被视作一个循环数组。请你构建一个同样大小的新数组 re

2025-06-26：转换数组。用go语言，给你一个整数数组 nums，它被视作一个循环数组。请你构建一个同样大小的新数组 result，规则如下：

对于数组中的每个位置 i（0 到 nums.length - 1）：

• • 如果 nums[i] 是正数，向右移动 nums[i] 步，从当前位置出发，循环往右走，找到落脚位置，将该位置的值赋给 result[i]。
• • 如果 nums[i] 是负数，向左移动绝对值 abs(nums[i]) 步，从当前位置向左循环找落脚点，将落脚点的值赋给 result[i]。
• • 如果 nums[i] 是零，则直接将 nums[i] 的值赋给 result[i]。

这样，你会得到一个数组 result，其中每个元素是根据 nums 对应位置循环移动后的元素值。

1 <= nums.length <= 100。

-100 <= nums[i] <= 100。

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

输出： [1,1,1,3]。

解释：

对于 nums[0] 等于 3，向右移动 3 步到 nums[3]，因此 result[0] 为 1。

对于 nums[1] 等于 -2，向左移动 2 步到 nums[3]，因此 result[1] 为 1。

对于 nums[2] 等于 1，向右移动 1 步到 nums[3]，因此 result[2] 为 1。

对于 nums[3] 等于 1，向右移动 1 步到 nums[0]，因此 result[3] 为 3。

题目来自力扣3379。

分步骤描述过程：

1. 1. 初始化：
   • • 给定输入数组 nums = [3, -2, 1, 1]，长度为 4。
   • • 创建一个与 nums 长度相同的新数组 result，初始值为 [0, 0, 0, 0]。
2. 2. 处理每个元素：
   • • 遍历 nums 的每个元素 nums[i]，根据其值的正负或零，计算 result[i] 的值。
   • • i = 0：
     • • nums[0] = 3（正数），向右移动 3 步。
     • • 当前位置：0。
     • • 移动步骤：
       • • 第 1 步：从 0 向右到 1。
       • • 第 2 步：从 1 向右到 2。
       • • 第 3 步：从 2 向右到 3。
     • • 落脚点为 3，result[0] = nums[3] = 1。
     • • result 更新为 [1, 0, 0, 0]。
   • • i = 1：
     • • nums[1] = -2（负数），向左移动 2 步。
     • • 当前位置：1。
     • • 移动步骤：
       • • 第 1 步：从 1 向左到 0。
       • • 第 2 步：从 0 向左到 3（循环，因为 0 的左边是数组的末尾）。
     • • 落脚点为 3，result[1] = nums[3] = 1。
     • • result 更新为 [1, 1, 0, 0]。
   • • i = 2：
     • • nums[2] = 1（正数），向右移动 1 步。
     • • 当前位置：2。
     • • 移动步骤：
       • • 第 1 步：从 2 向右到 3。
     • • 落脚点为 3，result[2] = nums[3] = 1。
     • • result 更新为 [1, 1, 1, 0]。
   • • i = 3：
     • • nums[3] = 1（正数），向右移动 1 步。
     • • 当前位置：3。
     • • 移动步骤：
       • • 第 1 步：从 3 向右到 0（循环，因为 3 的右边是数组的开头）。
     • • 落脚点为 0，result[3] = nums[0] = 3。
     • • result 更新为 [1, 1, 1, 3]。
3. 3. 最终结果：
   • • 遍历完成后，result = [1, 1, 1, 3]。

时间复杂度：

• • 对于每个元素 nums[i]，计算 result[i] 时需要移动 abs(nums[i]) 步。
• • 最坏情况下，nums[i] 的绝对值最大为 100（根据题目约束），因此每个元素的处理时间为 O(100) = O(1)。
• • 数组长度为 n，因此总时间复杂度为 O(n)。

额外空间复杂度：

• • 需要额外创建一个长度为 n 的数组 result 存储结果。
• • 因此额外空间复杂度为 O(n)。

总结：

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

Go完整代码如下：

.

package main

import"fmt"

func constructTransformedArray(nums []int) []int {
    n := len(nums)
    result := make([]int, n)
    for i, x := range nums {
        result[i] = nums[((i+x)%n+n)%n] // 保证结果在 [0,n-1] 中
    }
    return result
}

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

Python完整代码如下：

.

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

def construct_transformed_array(nums):
    n = len(nums)
    result = [0] * n
    for i, x in enumerate(nums):
        result[i] = nums[(i + x) % n]  # 保证结果在 [0, n-1] 中循环取值
    return result

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