Solution Explanation: Build Array from Permutation

This problem asks to create a new array ans where ans[i] = nums[nums[i]]. This means we're using the value at each index of nums as an index into nums again to get the corresponding value for ans.

Approach

The most straightforward approach is to iterate through the input array nums and, for each element, use it as an index to access the element in nums again. This resulting value is then placed in the corresponding index of the output array ans.

Code Implementation (Python)

class Solution:
    def buildArray(self, nums: List[int]) -> List[int]:
        ans = []
        for i in range(len(nums)):
            ans.append(nums[nums[i]])
        return ans

This code iterates through nums using a for loop. Inside the loop, nums[nums[i]] directly computes the element for ans[i]. The computed element is added to the ans list. Finally, the ans list is returned.

A more concise Python solution using list comprehension:

class Solution:
    def buildArray(self, nums: List[int]) -> List[int]:
        return [nums[i] for i in nums]

This single line achieves the same result more efficiently.

Time and Space Complexity Analysis

• Time Complexity: O(n), where n is the length of the input array nums. We iterate through the array once to build the ans array.
• Space Complexity: O(n). We create a new array ans of the same size as nums to store the result. If we disregard the space used for the output array, the space complexity becomes O(1) as we only use a constant amount of extra space during computation.

Code Implementation in Other Languages

The solution is similar in other languages, mainly differing in syntax. Here are examples in a few other languages:

Java:

class Solution {
    public int[] buildArray(int[] nums) {
        int[] ans = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            ans[i] = nums[nums[i]];
        }
        return ans;
    }
}

C++:

class Solution {
public:
    vector<int> buildArray(vector<int>& nums) {
        vector<int> ans;
        for (int i = 0; i < nums.size(); ++i) {
            ans.push_back(nums[nums[i]]);
        }
        return ans;
    }
};

JavaScript:

var buildArray = function(nums) {
    let ans = [];
    for (let i = 0; i < nums.length; i++) {
        ans.push(nums[nums[i]]);
    }
    return ans;
};

The core logic remains consistent across all languages: iterating through the input array and using its elements as indices to create the output array. The time and space complexities remain the same.