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

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

o 如果 nums[i] 是正数，向右移动 nums[i] 步，从当前位置出发，循环往右走，找到落脚位置，将该位置的值赋给 result[i]。

o 如果 nums[i] 是负数，向左移动绝对值 abs(nums[i]) 步，从当前位置向左循环找落脚点，将落脚点的值赋给 result[i]。

o 如果 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. 初始化：

o 给定输入数组 nums = [3, -2, 1, 1]，长度为 4。

o 创建一个与 nums 长度相同的新数组 result，初始值为 [0, 0, 0, 0]。

2. 处理每个元素：

o 遍历 nums 的每个元素 nums[i]，根据其值的正负或零，计算 result[i] 的值。

o i = 0：

o nums[0] = 3（正数），向右移动 3 步。

o 当前位置：0。

o 移动步骤：

o 第 1 步：从 0 向右到 1。

o 第 2 步：从 1 向右到 2。

o 第 3 步：从 2 向右到 3。

o 落脚点为 3，result[0] = nums[3] = 1。

o result 更新为 [1, 0, 0, 0]。

o i = 1：

o nums[1] = -2（负数），向左移动 2 步。

o 当前位置：1。

o 移动步骤：

o 第 1 步：从 1 向左到 0。

o 第 2 步：从 0 向左到 3（循环，因为 0 的左边是数组的末尾）。

o 落脚点为 3，result[1] = nums[3] = 1。

o result 更新为 [1, 1, 0, 0]。

o i = 2：

o nums[2] = 1（正数），向右移动 1 步。

o 当前位置：2。

o 移动步骤：

o 第 1 步：从 2 向右到 3。

o 落脚点为 3，result[2] = nums[3] = 1。

o result 更新为 [1, 1, 1, 0]。

o i = 3：

o nums[3] = 1（正数），向右移动 1 步。

o 当前位置：3。

o 移动步骤：

o 第 1 步：从 3 向右到 0（循环，因为 3 的右边是数组的开头）。

o 落脚点为 0，result[3] = nums[0] = 3。

o result 更新为 [1, 1, 1, 3]。

3. 最终结果：

o 遍历完成后，result = [1, 1, 1, 3]。

时间复杂度：

o 对于每个元素 nums[i]，计算 result[i] 时需要移动 abs(nums[i]) 步。

o 最坏情况下，nums[i] 的绝对值最大为 100（根据题目约束），因此每个元素的处理时间为 O(100) = O(1)。

o 数组长度为 n，因此总时间复杂度为 O(n)。

额外空间复杂度：

o 需要额外创建一个长度为 n 的数组 result 存储结果。

o 因此额外空间复杂度为 O(n)。

总结：

o 总时间复杂度：O(n)。

o 总额外空间复杂度：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)

·

我们相信Go语言和算法为普通开发者提供了困境的“面试利器”，并致力于分享全面的编程知识。在这里，您可以找到最新的Go语言教程、算法解析、提升面试竞争力的秘籍以及行业动态。

欢迎关注“福大规模架构师每日一题”，让 Go 语言和算法助力您的职业发展

·