Concatenation of Array - Practice Coding Problems

Concatenation of Array - Problem

Array Simulation Easy

Array Concatenation Challenge

You're given an integer array nums of length n, and your task is to create a new array that contains the original array twice - essentially concatenating the array with itself.

More specifically, you need to create an array ans of length 2n where:
• The first n elements are identical to the original array: ans[i] == nums[i]
• The next n elements are a copy of the original array: ans[i + n] == nums[i]

For example, if nums = [1,2,1], then ans = [1,2,1,1,2,1]

Goal: Return the concatenated array ans.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,1]

› Output: [1,2,1,1,2,1]

💡 Note: The array is concatenated with itself. First copy: [1,2,1], second copy: [1,2,1], result: [1,2,1,1,2,1]

example_2.py — Single Element

$ Input: nums = [1,3,2,1]

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

💡 Note: Four elements are duplicated to create an 8-element array where the second half mirrors the first half exactly

example_3.py — Minimum Case

$ Input: nums = [5]

› Output: [5,5]

💡 Note: Single element array becomes a two-element array with the same value repeated twice

Visualization

Tap to expand

Understanding the Visualization

Setup

Create a new array twice the size of the original

Single Pass

For each element at position i, place it at both position i and position i+n

Complete

Result contains the original array followed by its exact duplicate

Key Takeaway

🎯 Key Insight: Since we know the exact target positions (i and i+n), we can efficiently fill both positions in a single pass, making this an optimal O(n) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the input array of length n, performing constant time operations for each element

✓ Linear Growth

Space Complexity

O(n)

We create a new array of size 2n to store the result, so space complexity is O(n) additional space

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ n ≤ 1000
1 ≤ nums[i] ≤ 1000

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a single-pass approach where we iterate through the input array once and fill both positions (i and i+n) for each element simultaneously. This achieves O(n) time complexity with minimal code and maximum efficiency.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Two Separate Loops)	O(n)	O(n)	Copy elements twice using two separate loops
One-Pass Optimal Solution	O(n)	O(n)	Fill both positions for each element in a single loop iteration

Brute Force (Two Separate Loops) — Algorithm Steps

Create a new array of size 2n
First loop: copy nums[i] to ans[i] for i = 0 to n-1
Second loop: copy nums[i] to ans[i+n] for i = 0 to n-1
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Arrays

Create result array of size 2n, prepare to copy from input array

First Pass

Copy all elements from nums to first half of result array

Second Pass

Copy all elements from nums again to second half of result array

Result

Final concatenated array with original array repeated twice

Code -

solution.c — C

int* getConcatenation(int* nums, int numsSize, int* returnSize) {
    *returnSize = 2 * numsSize;
    int* ans = (int*)malloc((*returnSize) * sizeof(int));
    
    // First pass: copy original elements
    for (int i = 0; i < numsSize; i++) {
        ans[i] = nums[i];
    }
    
    // Second pass: copy duplicate elements
    for (int i = 0; i < numsSize; i++) {
        ans[i + numsSize] = nums[i];
    }
    
    return ans;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through the input array twice, each taking O(n) time, so total is O(2n) = O(n)

✓ Linear Growth

Space Complexity

O(n)

We create a new array of size 2n to store the result, so space complexity is O(n) additional space

⚡ Linearithmic Space

Constraints

n == nums.length
1 ≤ n ≤ 1000
1 ≤ nums[i] ≤ 1000

89.3K Views

Medium Frequency

~5 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Two Separate Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler