Create Target Array in the Given Order

Create Target Array in the Given Order - Problem

Array Simulation Easy

Given two arrays of integers nums and index. Your task is to create target array under the following rules:

Rules:

Initially target array is empty.
From left to right read nums[i] and index[i], insert at index index[i] the value nums[i] in target array.
Repeat the previous step until there are no elements to read in nums and index.

Return the target array.

It is guaranteed that the insertion operations will be valid.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Step by step: Insert 0 at index 0: [0]. Insert 1 at index 1: [0,1]. Insert 2 at index 2: [0,1,2]. Insert 3 at index 2: [0,1,3,2]. Insert 4 at index 1: [0,4,1,3,2].

Example 2 — Minimum Size

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

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

💡 Note: Start with [1], then [1,2], [1,2,3], [1,2,3,4], finally insert 0 at position 0: [0,1,2,3,4].

Example 3 — All at Beginning

$ Input: nums = [1], index = [0]

› Output: [1]

💡 Note: Single element case: insert 1 at index 0 gives [1].

Constraints

1 ≤ nums.length, index.length ≤ 100
nums.length == index.length
0 ≤ nums[i] ≤ 100
0 ≤ index[i] ≤ i

Visualization

Tap to expand

Asked in

🍎 Apple 8 M Microsoft 5

The key insight is to simulate the insertion process step by step. Use a dynamic list that supports insertion at arbitrary positions. For each element, insert it at the specified index, which automatically shifts existing elements. Time: O(n²), Space: O(n).

Common Approaches

✓ Bit Manipulation

⏱️ Time: N/A Space: N/A

Simulation with List Insertion

⏱️ Time: O(n²) Space: O(n)

Create an empty list and for each pair (nums[i], index[i]), insert nums[i] at position index[i]. The list automatically handles shifting existing elements to the right.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* index, int indexSize, int* returnSize) {
    *returnSize = numsSize;
    int* result = (int*)malloc(*returnSize * sizeof(int));
    
    // Initialize result array
    for (int i = 0; i < *returnSize; i++) {
        result[i] = 0;
    }
    
    int currentSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int insertPos = index[i];
        
        // Shift elements to the right from insertPos
        for (int j = currentSize; j > insertPos; j--) {
            result[j] = result[j - 1];
        }
        
        // Insert the new element
        result[insertPos] = nums[i];
        currentSize++;
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    
    // Skip to opening bracket
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // Parse numbers
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse number
        int num = 0;
        int sign = 1;
        if (*p == '-') {
            sign = -1;
            p++;
        }
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        arr[(*size)++] = sign * num;
    }
}

int main() {
    static int nums[1000];
    static int index[1000];
    int numsSize = 0, indexSize = 0;
    char line[10000];
    
    // Read nums array
    if (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = 0;
        parseArray(line, nums, &numsSize);
    }
    
    // Read index array
    if (fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\n")] = 0;
        parseArray(line, index, &indexSize);
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, index, indexSize, &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

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

56.9K Views

Low Frequency

~10 min Avg. Time

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