Create Target Array in the Given Order - Practice Coding Problems

Create Target Array in the Given Order - Problem

Array Simulation Easy

Given two arrays of integers nums and index, your task is to dynamically build a target array by following a series of insertion operations.

Here's how it works:

Start with an empty target array
For each position i from left to right, insert the value nums[i] at position index[i] in the target array
When you insert at a position, all existing elements at that position and beyond shift to the right
Continue until all elements are processed

Example: If nums = [0,1,2,3,4] and index = [0,1,2,2,1], you would:

Insert 0 at position 0: [0]
Insert 1 at position 1: [0,1]
Insert 2 at position 2: [0,1,2]
Insert 3 at position 2: [0,1,3,2] (2 shifts right)
Insert 4 at position 1: [0,4,1,3,2] (1,3,2 shift right)

Return the final target array after all insertions.

Input & Output

example_1.py — 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: [] → [0] → [0,1] → [0,1,2] → [0,1,3,2] → [0,4,1,3,2]. Each insertion shifts existing elements at that position to the right.

example_2.py — Simple Sequential

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

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

💡 Note: Most insertions are at the end, except the last one inserts 0 at the beginning, shifting all elements right: [1] → [1,2] → [1,2,3] → [1,2,3,4] → [0,1,2,3,4].

example_3.py — Single Element

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

› Output: [1]

💡 Note: With only one element, we simply insert it at index 0 in the empty array, resulting in [1].

Constraints

1 ≤ nums.length, index.length ≤ 100
nums.length == index.length
0 ≤ nums[i] ≤ 100
0 ≤ index[i] ≤ i
All insertion operations are guaranteed to be valid

Visualization

Tap to expand

Understanding the Visualization

Empty Theater

Start with an empty row of seats (empty array)

First Guest Arrives

Person wants seat 0, sits down immediately

Second Guest

Person wants seat 1, sits next to the first person

Disruption!

New person wants seat 1 - everyone from seat 1 onwards shifts right

Final Arrangement

All guests are seated according to their arrival order and preferences

Key Takeaway

🎯 Key Insight: This problem is fundamentally about simulation - we need to replicate the exact insertion process. The 'brute force' approach of using built-in insertion operations is actually optimal because it naturally handles the complex shifting logic for us.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 Apple 5

The optimal approach is direct simulation using array insertion operations. Simply iterate through the input arrays and insert each nums[i] at position index[i]. The built-in insertion functions handle the shifting automatically, making this both the most intuitive and correct solution with O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation (Optimal)	O(n²)	O(n)	Build the target array by inserting each element at the specified index

Direct Simulation (Optimal) — Algorithm Steps

Initialize an empty result array
Iterate through both arrays simultaneously using index i
For each iteration, insert nums[i] at position index[i] in the result array
The insertion operation automatically shifts elements to the right
Return the final result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with empty array and first element to insert

First Insertion

Insert first element at specified index

Subsequent Insertions

Insert remaining elements, shifting existing ones

Final Result

Complete target array after all insertions

Code -

solution.c — C

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

void createTargetArray(int* nums, int numsSize, int* index, int* target) {
    int targetSize = 0;
    for (int i = 0; i < numsSize; i++) {
        // Shift elements to the right
        for (int j = targetSize; j > index[i]; j--) {
            target[j] = target[j-1];
        }
        // Insert the new element
        target[index[i]] = nums[i];
        targetSize++;
    }
}

int main() {
    char line[1000];
    int nums[100], index[100], target[100];
    int numsSize = 0, indexSize = 0;
    
    // Parse nums array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    // Parse index array
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[],\n ");
    while (token != NULL) {
        index[indexSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    createTargetArray(nums, numsSize, index, target);
    
    printf("[");
    for (int i = 0; i < numsSize; i++) {
        printf("%d", target[i]);
        if (i < numsSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In the worst case, each of the n insertions can shift up to n elements, resulting in O(n²) time complexity

⚠ Quadratic Growth

Space Complexity

O(n)

We need O(n) space to store the result array, which will contain exactly n elements

⚡ Linearithmic Space

68.2K Views

Medium Frequency

~8 min Avg. Time

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Simulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler