3379. Transformed Array

/**
 * Problem: LeetCode 3379 - Transformed Array
 * Difficulty: Easy
 * Language: Java
 * Author: CodeByTushu
 */
class Solution {
    public int[] constructTransformedArray(int[] nums) {
        int n = nums.length;
        int[] result = new int[n];

        for (int i = 0; i < n; i++) {
            // In a circular array of length n, moving nums[i] steps (positive for right,
            // negative for left) lands at ((i + nums[i]) % n + n) % n.
            int targetIndex = ((i + nums[i]) % n + n) % n;
            result[i] = nums[targetIndex];
        }

        return result;
    }
}

"""
Problem: LeetCode 3379 - Transformed Array
Difficulty: Easy
Language: Python
Author: CodeByTushu
"""
from typing import List

class Solution:
    def constructTransformedArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        result = [0] * n

        for i in range(n):
            # Python's modulo operator (%) naturally wraps negative results correctly into [0, n - 1]
            target_index = (i + nums[i]) % n
            result[i] = nums[target_index]

        return result

/**
 * Problem: LeetCode 3379 - Transformed Array
 * Difficulty: Easy
 * Language: C++
 * Author: CodeByTushu
 */
#include <vector>

using namespace std;

class Solution {
public:
    vector<int> constructTransformedArray(vector<int>& nums) {
        int n = nums.size();
        vector<int> result(n);

        for (int i = 0; i < n; i++) {
            // Normalize non-positive modulo results to standard positive circular index in [0, n - 1]
            int targetIndex = ((i + nums[i]) % n + n) % n;
            result[i] = nums[targetIndex];
        }

        return result;
    }
};

/**
 * Problem: LeetCode 3379 - Transformed Array
 * Difficulty: Easy
 * Language: JavaScript
 * Author: CodeByTushu
 */
/**
 * @param {number[]} nums
 * @return {number[]}
 */
var constructTransformedArray = function(nums) {
    const n = nums.length;
    const result = new Array(n);

    for (let i = 0; i < n; i++) {
        // Normalize JavaScript negative remainder via ((val % n) + n) % n
        const targetIndex = ((i + nums[i]) % n + n) % n;
        result[i] = nums[targetIndex];
    }

    return result;
};