questions C

backend/data/questions/concatenation-of-array.yaml

@@ -0,0 +1,160 @@
+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:
+  - two-pointers
+
+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.