Transformed Array

Transformed Array - Problem

Array Simulation Easy

You are given an integer array nums that represents a circular array. Your task is to create a new array result of the same size, following these rules:

For each index i (where 0 <= i < nums.length), perform the following independent actions:

If nums[i] > 0: Start at index i and move nums[i] steps to the right in the circular array. Set result[i] to the value of the index where you land.
If nums[i] < 0: Start at index i and move abs(nums[i]) steps to the left in the circular array. Set result[i] to the value of the index where you land.
If nums[i] == 0: Set result[i] to nums[i].

Return the new array result.

Note: Since nums is circular, moving past the last element wraps around to the beginning, and moving before the first element wraps back to the end.

Input & Output

Example 1 — Basic Circular Movement

$ Input: nums = [3,1,0,-1]

› Output: [-1,0,0,0]

💡 Note: Index 0: nums[0]=3, move 3 steps right: 0→1→2→3, result[0]=nums[3]=-1. Index 1: nums[1]=1, move 1 step right: 1→2, result[1]=nums[2]=0. Index 2: nums[2]=0, result[2]=0. Index 3: nums[3]=-1, move 1 step left: 3→2, result[3]=nums[2]=0.

Example 2 — Wrapping Around

$ Input: nums = [1,2,-1,0]

› Output: [2,0,2,0]

💡 Note: Index 0: move 1 right to position 1, get nums[1]=2. Index 1: move 2 right: 1→2→3, get nums[3]=0. Index 2: move 1 left: 2→1, get nums[1]=2. Index 3: nums[3]=0, stays 0.

Example 3 — Large Steps with Wrapping

$ Input: nums = [5,-3,2]

› Output: [2,-3,-3]

💡 Note: Index 0: move 5 right: 0→1→2→0→1→2, lands at 2, get nums[2]=2. Index 1: move 3 left: 1→0→2, lands at 2, get nums[2]=2. Index 2: move 2 right: 2→0→1, get nums[1]=-3.

Constraints

1 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use modular arithmetic to handle circular array navigation efficiently. Instead of counting steps one by one, we can directly calculate the target position using (i + steps) % n for positive moves and handle negative modulo properly for leftward moves. Best approach is Direct Modular Calculation with Time: O(n), Space: O(1).

Common Approaches

✓ Direct Modular Calculation

⏱️ Time: O(n) Space: O(1)

Instead of counting steps one by one, we use modular arithmetic to directly compute where we'll land. For positive numbers, add the steps and mod by length. For negative numbers, subtract and handle negative modulo properly.

Step-by-Step Simulation

⏱️ Time: O(n × k) Space: O(1)

For each position, count steps one by one, wrapping around when reaching array boundaries. This approach directly follows the problem description by simulating each step of movement.

Direct Modular Calculation — Algorithm Steps

For each index, check if value is positive, negative, or zero
For positive: calculate (i + nums[i]) % n
For negative: calculate (i - abs(nums[i])) % n, handle negative modulo
For zero: copy the value directly

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Target

Use (i + steps) % n for direct positioning

Handle Negative

For negative steps, ensure positive result

Get Value

Access value at calculated position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == 0) {
            result[i] = nums[i];
        } else if (nums[i] > 0) {
            // Move right
            int targetPos = (i + nums[i]) % numsSize;
            result[i] = nums[targetPos];
        } else {
            // Move left - handle negative modulo
            int targetPos = ((i + nums[i]) % numsSize + numsSize) % numsSize;
            result[i] = nums[targetPos];
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = solution(nums, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each calculation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

245 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Modular Calculation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler