# Solving Leetcode Interviews in Seconds with AI: Check Array Formation Through Concatenation


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1640" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an array of distinct integers arr and an array of integer arrays pieces, where the integers in pieces are distinct. Your goal is to form arr by concatenating the arrays in pieces in any order. However, you are not allowed to reorder the integers in each array pieces[i]. Return true if it is possible to form the array arr from pieces. Otherwise, return false.   Example 1:  Input: arr = [15,88], pieces = [[88],[15]] Output: true Explanation: Concatenate [15] then [88]  Example 2:  Input: arr = [49,18,16], pieces = [[16,18,49]] Output: false Explanation: Even though the numbers match, we cannot reorder pieces[0].  Example 3:  Input: arr = [91,4,64,78], pieces = [[78],[4,64],[91]] Output: true Explanation: Concatenate [91] then [4,64] then [78]    Constraints:  1 <= pieces.length <= arr.length <= 100 sum(pieces[i].length) == arr.length 1 <= pieces[i].length <= arr.length 1 <= arr[i], pieces[i][j] <= 100 The integers in arr are distinct. The integers in pieces are distinct (i.e., If we flatten pieces in a 1D array, all the integers in this array are distinct).  

	# Explanation
	Here's a breakdown of the solution and the code:

*   **High-Level Approach:**
    *   Create a dictionary (hash map) to store the starting element of each piece and its corresponding array. This allows for O(1) lookup of which piece (if any) starts with a particular element in `arr`.
    *   Iterate through the `arr` array. At each element, check if it is the starting element of any piece.
    *   If it is, verify if the entire piece matches the corresponding portion of the `arr` array. If any mismatch is found, return `False`.

*   **Complexity:**
    *   Runtime: O(N), where N is the length of `arr`.
    *   Storage: O(P), where P is the number of pieces (in the worst case, close to N).

	
	# Code
	```python
	def canFormArray(arr, pieces):
    """
    Checks if arr can be formed by concatenating arrays in pieces.

    Args:
        arr: A list of distinct integers.
        pieces: A list of lists of integers.

    Returns:
        True if arr can be formed from pieces, False otherwise.
    """

    piece_map = {piece[0]: piece for piece in pieces}
    i = 0
    while i < len(arr):
        if arr[i] not in piece_map:
            return False

        piece = piece_map[arr[i]]
        piece_len = len(piece)

        if arr[i:i + piece_len] != piece:
            return False

        i += piece_len

    return True
	```