Build Array from Permutation - Practice Coding Problems

Build Array from Permutation - Problem

Array Simulation Easy

You're given a special array called a zero-based permutation - an array containing each integer from 0 to n-1 exactly once, where n is the array length.

Your task is to transform this permutation into a new array using a simple rule: for each position i, the new value should be nums[nums[i]]. In other words, use the value at position i as an index to look up another value in the original array.

Example: If nums = [0,2,1,5,3,4], then:

Position 0: nums[nums[0]] = nums[0] = 0
Position 1: nums[nums[1]] = nums[2] = 1
Position 2: nums[nums[2]] = nums[1] = 2

This creates a double lookup pattern that's common in array manipulation problems!

Input & Output

example_1.py — Basic Permutation

$ Input: [0,2,1,5,3,4]

› Output: [0,1,2,4,5,3]

💡 Note: At index 0: nums[nums[0]] = nums[0] = 0. At index 1: nums[nums[1]] = nums[2] = 1. At index 2: nums[nums[2]] = nums[1] = 2. Continuing this pattern gives us [0,1,2,4,5,3].

example_2.py — Small Array

$ Input: [5,0,1,2,3,4]

› Output: [4,5,0,1,2,3]

💡 Note: Each element points to the next position in a circular fashion. nums[0]=5 so ans[0]=nums[5]=4, nums[1]=0 so ans[1]=nums[0]=5, and so on.

example_3.py — Single Element

$ Input: [0]

› Output: [0]

💡 Note: With only one element, nums[0] = 0, so ans[0] = nums[nums[0]] = nums[0] = 0. The array remains unchanged.

Visualization

Tap to expand

Understanding the Visualization

Read the Clue

At position i, read the value nums[i] which tells us which position to look at next

Follow the Clue

Go to position nums[i] and read the treasure value nums[nums[i]]

Store the Treasure

Place the treasure value in the result array at position i

Key Takeaway

🎯 Key Insight: Since it's a permutation, every 'clue' (nums[i]) points to a valid position, making the double lookup safe and straightforward!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once to perform the lookup

✓ Linear Growth

Space Complexity

O(n)

We need additional space for the result array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] < nums.length
nums is a permutation of integers in range [0, nums.length - 1]

Asked in

a Amazon 15 G Google 8 f Meta 5 ⊞ Microsoft 3

This problem is a straightforward array simulation that requires applying a double lookup transformation. The key insight is that since the input is guaranteed to be a valid permutation, we can safely perform nums[nums[i]] without bounds checking. The optimal approach is simply to iterate through each index once, making it an O(n) time and O(n) space solution.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation (Optimal)	O(n)	O(n)	Directly apply the transformation rule for each position

Direct Simulation (Optimal) — Algorithm Steps

Create a result array of the same length as input
For each index i from 0 to n-1
Set result[i] = nums[nums[i]] (double lookup)
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Result Array

Create an empty result array of the same size

Apply Transformation

For each index i, set result[i] = nums[nums[i]]

Complete Result

Return the fully transformed array

Code -

solution.c — C

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

int* buildArray(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        result[i] = nums[nums[i]];
    }
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int returnSize;
    int* result = buildArray(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)

We visit each element exactly once to perform the lookup

✓ Linear Growth

Space Complexity

O(n)

We need additional space for the result array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] < nums.length
nums is a permutation of integers in range [0, nums.length - 1]

45.0K Views

High Frequency

~8 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Direct Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler