Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1920.html

1920. Build Array from Permutation

Level

Easy

Description

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).

Example 1:

Input: nums = [0,2,1,5,3,4]
Output: [0,1,2,4,5,3]
Explanation: The array ans is built as follows: 
ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]]
    = [nums[0], nums[2], nums[1], nums[5], nums[3], nums[4]]
    = [0,1,2,4,5,3]
**Example 2:**

Input: nums = [5,0,1,2,3,4] Output: [4,5,0,1,2,3] Explanation: The array ans is built as follows: ans = [nums[nums[0]], nums[nums[1]], nums[nums[2]], nums[nums[3]], nums[nums[4]], nums[nums[5]]] = [nums[5], nums[0], nums[1], nums[2], nums[3], nums[4]] = [4,5,0,1,2,3] ```

Constraints:

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

Solution

Simply create the array ans as described in the problem, and return ans.

  • class Solution {
        public int[] buildArray(int[] nums) {
            int length = nums.length;
            int[] array = new int[length];
            for (int i = 0; i < length; i++)
                array[i] = nums[nums[i]];
            return array;
        }
    }
    
    ############
    
    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;
        }
    }
    
  • // OJ: https://leetcode.com/problems/build-array-from-permutation/
    // Time: O(N)
    // Space: O(1)
    class Solution {
    public:
        vector<int> buildArray(vector<int>& A) {
            vector<int> ans(A.size());
            for (int i = 0; i < A.size(); ++i) {
                ans[i] = A[A[i]];
            }
            return ans;
        }
    };
    
  • class Solution:
        def buildArray(self, nums: List[int]) -> List[int]:
            return [nums[num] for num in nums]
    
    ############
    
    # 1920. Build Array from Permutation
    # https://leetcode.com/problems/build-array-from-permutation/
    
    class Solution:
        def buildArray(self, nums: List[int]) -> List[int]:
            res = [0] * len(nums)
            
            for i in range(len(nums)):
                res[i] = nums[nums[i]]
            
            return res
    
    
  • func buildArray(nums []int) []int {
    	ans := make([]int, len(nums))
    	for i, num := range nums {
    		ans[i] = nums[num]
    	}
    	return ans
    }
    
  • function buildArray(nums: number[]): number[] {
        return nums.map(v => nums[v]);
    }
    
    
  • /**
     * @param {number[]} nums
     * @return {number[]}
     */
    var buildArray = function (nums) {
        let ans = [];
        for (let i = 0; i < nums.length; ++i) {
            ans[i] = nums[nums[i]];
        }
        return ans;
    };
    
    
  • impl Solution {
        pub fn build_array(nums: Vec<i32>) -> Vec<i32> {
            nums.iter().map(|&v| nums[v as usize]).collect()
        }
    }
    
    

All Problems

All Solutions