Build Array from Permutation

Build Array from Permutation - Problem

Array Simulation Easy

Given a zero-based permutation nums (0-indexed), build an array ans of the same length where ans[i] = nums[nums[i]] for each 0 <= i < nums.length and return it.

A zero-based permutation nums is an array of distinct integers from 0 to nums.length - 1 (inclusive).

Input & Output

Example 1 — Basic Permutation

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

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

💡 Note: ans[0] = nums[nums[0]] = nums[0] = 0, ans[1] = nums[nums[1]] = nums[2] = 1, ans[2] = nums[nums[2]] = nums[1] = 2, and so on.

Example 2 — Simple Case

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

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

💡 Note: ans[0] = nums[5] = 4, ans[1] = nums[0] = 5, ans[2] = nums[1] = 0, creating a shifted pattern.

Example 3 — Minimum Size

$ Input: nums = [0]

› Output: [0]

💡 Note: Single element case: ans[0] = nums[nums[0]] = nums[0] = 0.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] < nums.length
The elements in nums are distinct.

Visualization

Tap to expand

Asked in

L LeetCode 15 G Google 8

Build a new array where ans[i] = nums[nums[i]]. The key insight is to use each array element as an index to look up values. Best approach is the direct construction with O(n) time and O(n) space, though an O(1) space solution exists using mathematical encoding.

Common Approaches

Approach	Time	Space	Notes
✓ In-Place with Mathematical Encoding	O(n)	O(1)	Encode both old and new values in the same array using mathematical properties
Direct Array Construction	O(n)	O(n)	Build result array by directly applying the transformation formula

In-Place with Mathematical Encoding — Algorithm Steps

First pass: encode both values using nums[i] += (nums[nums[i]] % n) * n
Second pass: decode new values using nums[i] // n

Visualization

Tap to expand

Step-by-Step Walkthrough

Encode

Add (nums[nums[i]] % n) * n to each element

Decode

Extract new values by dividing by n

Result

Array now contains the transformed values

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    
    // First pass: encode both old and new values
    for (int i = 0; i < numsSize; i++) {
        nums[i] += (nums[nums[i]] % numsSize) * numsSize;
    }
    
    // Second pass: extract the new values
    for (int i = 0; i < numsSize; i++) {
        nums[i] /= numsSize;
    }
    
    return nums;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array of length n

✓ Linear Growth

Space Complexity

O(1)

No extra space needed, modifies input in-place

✓ Linear Space

60.9K Views

Medium Frequency

~5 min Avg. Time

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

In-Place with Mathematical Encoding — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler