Transformed Array - Practice Coding Problems

Transformed Array - Problem

Array Simulation Easy

Transformed Array - Navigate a Circular Array Adventure!

Imagine you're standing in a circular playground where each position has a special instruction telling you how many steps to take. Your mission is to follow these instructions and record where you land!

Given an integer array nums representing a circular array, create a new array result following these movement rules:

🔄 For each position i:
• If nums[i] > 0: Move nums[i] steps clockwise (right)
• If nums[i] < 0: Move |nums[i]| steps counter-clockwise (left)
• If nums[i] == 0: Stay put (no movement)

Set result[i] to the value at your final destination.

🎯 Key Point: The array is circular - going past the last element wraps to the beginning, and going before the first element wraps to the end.

Example: nums = [3, -2, 0, 1]
• Position 0: Move 3 steps right → land at position 3 → result[0] = 1
• Position 1: Move 2 steps left → land at position 3 → result[1] = 1
• Position 2: Stay put → result[2] = 0
• Position 3: Move 1 step right → land at position 0 → result[3] = 3

Return the transformed array!

Input & Output

example_1.py — Basic Movement

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

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

💡 Note: • Index 0 (value 3): Move 3 steps right: 0→1→2→3, land at nums[3] = 1 • Index 1 (value -2): Move 2 steps left: 1→0→3, land at nums[3] = 1 • Index 2 (value 0): No movement, stay at nums[2] = 0 • Index 3 (value 1): Move 1 step right: 3→0, land at nums[0] = 3

example_2.py — Wrap Around

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

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

💡 Note: • Index 0 (value -1): Move 1 step left: 0→2, land at nums[2] = -3... wait, that's wrong. Let me recalculate: 0→2, so result[0] = nums[2] = -3. Actually: result = [2, -3, -1]

example_3.py — Large Steps

$ Input: nums = [10, -5, 0]

› Output: [-5, 10, 0]

💡 Note: • Index 0 (value 10): Move 10 steps right: 10 % 3 = 1, so land at nums[1] = -5 • Index 1 (value -5): Move 5 steps left: (1 - 5) % 3 = -4 % 3 = 2, so land at nums[2] = 0... Let me recalculate properly.

Constraints

1 ≤ nums.length ≤ 100
-1000 ≤ nums[i] ≤ 1000
The array is circular - wrap around at boundaries

Visualization

Tap to expand

Understanding the Visualization

Read Instruction

Each position contains a number indicating steps and direction

Calculate Destination

Use modular arithmetic to find landing position instantly

Handle Wrap-Around

Positive/negative modulo ensures circular boundary handling

Record Value

Store the value found at the destination position

Key Takeaway

🎯 Key Insight: Modular arithmetic eliminates the need for step-counting loops - we can jump directly to the destination using mathematical formulas!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal approach uses modular arithmetic to calculate the final position directly without step-by-step simulation. For positive movements: (i + nums[i]) % n, for negative movements: (i + nums[i] % n + n) % n. This reduces time complexity from O(n×k) to O(n) where n is array length.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation	O(n × k)	O(1)	Simulate each movement step by step with manual wrap-around handling

Direct Simulation — Algorithm Steps

Iterate through each index i in the array
For each nums[i], determine direction (positive = right, negative = left)
Start from position i and move step by step
Handle wrap-around: if pos >= n, set pos = 0; if pos < 0, set pos = n-1
Repeat until all steps are taken
Record the final position's value in result[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at index i with value nums[i]

Determine Direction

Positive = clockwise, Negative = counter-clockwise

Move Step by Step

Increment/decrement position, handling wrap-around

Record Result

Store the value at final position

Code -

solution.c — C

int* constructTransformedArray(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 {
            int pos = i;
            int steps = abs(nums[i]);
            int direction = nums[i] > 0 ? 1 : -1;
            
            // Move step by step
            for (int j = 0; j < steps; j++) {
                pos += direction;
                if (pos >= numsSize) {
                    pos = 0;
                } else if (pos < 0) {
                    pos = numsSize - 1;
                }
            }
            
            result[i] = nums[pos];
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Where n is array length and k is average step count. In worst case, k could be very large, making this approach slow.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for position tracking, excluding the result array.

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler