title: Concatenation of Array
slug: concatenation-of-array
difficulty: easy
leetcode_id: 1929
leetcode_url: https://leetcode.com/problems/concatenation-of-array/
categories:
  - arrays
patterns:
  - slug: two-pointers
    is_optimal: true

function_signature: "def get_concatenation(nums: list[int]) -> list[int]:"

test_cases:
  visible:
    - input: { nums: [1, 2, 1] }
      expected: [1, 2, 1, 1, 2, 1]
    - input: { nums: [1, 3, 2, 1] }
      expected: [1, 3, 2, 1, 1, 3, 2, 1]
  hidden:
    - input: { nums: [1] }
      expected: [1, 1]
    - input: { nums: [5, 4, 3, 2, 1] }
      expected: [5, 4, 3, 2, 1, 5, 4, 3, 2, 1]
    - input: { nums: [1, 1, 1] }
      expected: [1, 1, 1, 1, 1, 1]
    - input: { nums: [7] }
      expected: [7, 7]
    - input: { nums: [100, 200] }
      expected: [100, 200, 100, 200]

description: |
  Given an integer array `nums` of length `n`, you want to create an array `ans` of length `2n` where `ans[i] == nums[i]` and `ans[i + n] == nums[i]` for `0 <= i < n` (**0-indexed**).

  Specifically, `ans` is the **concatenation** of two `nums` arrays.

  Return *the array* `ans`.

constraints: |
  - `n == nums.length`
  - `1 <= n <= 1000`
  - `1 <= nums[i] <= 1000`

examples:
  - input: "nums = [1,2,1]"
    output: "[1,2,1,1,2,1]"
    explanation: "The array ans is formed as follows: ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]] = [1,2,1,1,2,1]"
  - input: "nums = [1,3,2,1]"
    output: "[1,3,2,1,1,3,2,1]"
    explanation: "The array ans is formed as follows: ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]] = [1,3,2,1,1,3,2,1]"

explanation:
  intuition: |
    Imagine you have a deck of cards and you want to create a copy of it placed right after the original. The result is simply the same sequence repeated twice.

    This problem is fundamentally about **array duplication and concatenation**. The key insight is that we need to produce an output array that contains the original array followed by itself. There's no complex logic involved — we're simply copying elements twice.

    Think of it like this: if you have a row of numbered boxes, you create an identical row and place it at the end. The first half of your result mirrors the input, and so does the second half.

    The simplicity of this problem makes it an excellent introduction to basic array manipulation and understanding index relationships.

  approach: |
    We solve this using a **Direct Concatenation Approach**:

    **Step 1: Create the result array**

    - Initialise an empty array `ans` that will hold `2n` elements
    - We can either pre-allocate space or build it dynamically

    &nbsp;

    **Step 2: Fill the first half**

    - Copy all elements from `nums` into positions `0` to `n-1` of `ans`
    - This mirrors the original array exactly

    &nbsp;

    **Step 3: Fill the second half**

    - Copy all elements from `nums` into positions `n` to `2n-1` of `ans`
    - This creates the duplicate portion

    &nbsp;

    **Step 4: Return the result**

    - Return `ans` containing the concatenated array

    &nbsp;

    In most languages, this can be simplified using built-in concatenation operators or methods. Python allows `nums + nums` or `nums * 2` for direct concatenation.

  common_pitfalls:
    - title: Off-by-One Errors in Manual Implementation
      description: |
        When manually filling the result array using indices, a common mistake is getting the index calculation wrong for the second half.

        For the second half, element `nums[i]` should go to `ans[i + n]`, not `ans[i + n - 1]` or `ans[i + n + 1]`.

        Example with `nums = [1, 2, 3]` (n=3):
        - `nums[0]` goes to `ans[0]` AND `ans[3]`
        - `nums[1]` goes to `ans[1]` AND `ans[4]`
        - `nums[2]` goes to `ans[2]` AND `ans[5]`
      wrong_approach: "Using incorrect index offset for second half"
      correct_approach: "Use ans[i + n] = nums[i] for the second half"

    - title: Modifying the Original Array
      description: |
        Some approaches might try to extend the original array in-place. While this works, it modifies the input which may not be desired.

        Creating a new array preserves the original input and is generally cleaner.
      wrong_approach: "Extending nums in-place"
      correct_approach: "Create a new result array"

    - title: Overcomplicating the Solution
      description: |
        This is intentionally a simple problem. Don't overthink it by using complex data structures or algorithms.

        A straightforward concatenation using language features is the expected solution. In Python, `nums + nums` or `nums * 2` is perfectly acceptable and idiomatic.

  key_takeaways:
    - "**Array concatenation basics**: Understanding how to combine arrays is fundamental to many problems"
    - "**Index relationships**: The mapping `ans[i] = ans[i + n] = nums[i]` demonstrates how indices relate across duplicated data"
    - "**Language idioms**: Most languages have built-in ways to concatenate arrays — use them when appropriate"
    - "**Simplicity is valid**: Not every problem requires complex algorithms; recognising simple solutions is a skill"

  time_complexity: "O(n). We iterate through the input array once (or twice with explicit copying), where `n` is the length of `nums`."
  space_complexity: "O(n). The output array `ans` has length `2n`, which is O(n) additional space. Note: if we count output as required space, it's O(2n) = O(n)."

solutions:
  - approach_name: Built-in Concatenation
    is_optimal: true
    code: |
      def get_concatenation(nums: list[int]) -> list[int]:
          # Python allows direct list concatenation with +
          # This creates a new list with nums followed by nums
          return nums + nums
    explanation: |
      **Time Complexity:** O(n) — Creating the concatenated list requires copying all elements twice.

      **Space Complexity:** O(n) — The result array has `2n` elements.

      This is the most Pythonic solution. The `+` operator creates a new list containing all elements from both operands. Alternatively, `nums * 2` achieves the same result by repeating the list twice.

  - approach_name: Manual Index Copying
    is_optimal: false
    code: |
      def get_concatenation(nums: list[int]) -> list[int]:
          n = len(nums)
          # Pre-allocate array of size 2n
          ans = [0] * (2 * n)

          # Fill both halves in a single pass
          for i in range(n):
              # First half: direct copy
              ans[i] = nums[i]
              # Second half: offset by n
              ans[i + n] = nums[i]

          return ans
    explanation: |
      **Time Complexity:** O(n) — Single pass through the input array.

      **Space Complexity:** O(n) — The result array has `2n` elements.

      This approach explicitly demonstrates the index relationship described in the problem. While more verbose than using built-in concatenation, it clearly shows how `ans[i]` and `ans[i + n]` both receive `nums[i]`. This is useful for understanding the underlying mechanics and translates well to languages without convenient concatenation operators.

  - approach_name: List Comprehension
    is_optimal: false
    code: |
      def get_concatenation(nums: list[int]) -> list[int]:
          n = len(nums)
          # Use modulo to wrap index back to start
          return [nums[i % n] for i in range(2 * n)]
    explanation: |
      **Time Complexity:** O(n) — Iterates through `2n` indices.

      **Space Complexity:** O(n) — The result list has `2n` elements.

      This approach uses modulo arithmetic to cycle through the original array twice. When `i >= n`, the expression `i % n` wraps back to give indices `0, 1, 2, ...` again. While clever, it's less readable than direct concatenation and adds unnecessary computation with the modulo operation.
