Transformed Array - Practice Coding Problems

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,1,0,3]

💡 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,-1,1,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,5,-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→1, lands at 1, get nums[1]=-3. 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

Understanding the Visualization

Input

Array with positive (right), negative (left), and zero (stay) values

Process

Move in circular fashion based on each element's value

Output

New array with values from landing positions

Key Takeaway

🎯 Key Insight: Use modular arithmetic to handle circular array navigation efficiently without step-by-step counting

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

Approach	Time	Space	Notes
✓ Direct Modular Calculation	O(n)	O(1)	Use modular arithmetic to directly calculate the landing position
Step-by-Step Simulation	O(n × k)	O(1)	For each element, simulate moving step by step in the circular array

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;
}

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