# Solving Leetcode Interviews in Seconds with AI: Recover the Original Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2122" 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
	> Alice had a 0-indexed array arr consisting of n positive integers. She chose an arbitrary positive integer k and created two new 0-indexed integer arrays lower and higher in the following manner:  lower[i] = arr[i] - k, for every index i where 0 <= i < n higher[i] = arr[i] + k, for every index i where 0 <= i < n  Unfortunately, Alice lost all three arrays. However, she remembers the integers that were present in the arrays lower and higher, but not the array each integer belonged to. Help Alice and recover the original array. Given an array nums consisting of 2n integers, where exactly n of the integers were present in lower and the remaining in higher, return the original array arr. In case the answer is not unique, return any valid array. Note: The test cases are generated such that there exists at least one valid array arr.   Example 1:  Input: nums = [2,10,6,4,8,12] Output: [3,7,11] Explanation: If arr = [3,7,11] and k = 1, we get lower = [2,6,10] and higher = [4,8,12]. Combining lower and higher gives us [2,6,10,4,8,12], which is a permutation of nums. Another valid possibility is that arr = [5,7,9] and k = 3. In that case, lower = [2,4,6] and higher = [8,10,12].   Example 2:  Input: nums = [1,1,3,3] Output: [2,2] Explanation: If arr = [2,2] and k = 1, we get lower = [1,1] and higher = [3,3]. Combining lower and higher gives us [1,1,3,3], which is equal to nums. Note that arr cannot be [1,3] because in that case, the only possible way to obtain [1,1,3,3] is with k = 0. This is invalid since k must be positive.  Example 3:  Input: nums = [5,435] Output: [220] Explanation: The only possible combination is arr = [220] and k = 215. Using them, we get lower = [5] and higher = [435].    Constraints:  2 * n == nums.length 1 <= n <= 1000 1 <= nums[i] <= 109 The test cases are generated such that there exists at least one valid array arr.  

	# Explanation
	Here's the breakdown of the approach, complexities, and the Python code:

*   **High-Level Approach:**
    *   Sort the input array `nums`. Iterate through the sorted `nums` and consider each element as a potential `lower[0]`.
    *   For each potential `lower[0]`, deduce `k` using the fact that `higher[0]` must also exist in `nums`. If a valid `k` is found, reconstruct the `lower` and `higher` arrays and verify if they match the input `nums`.
    *   If a valid `arr` is found, return it.

*   **Complexity Analysis:**
    *   Runtime Complexity: O(n^2), where n is the length of the array `arr` (nums length is 2n). Sorting takes O(n log n), and the nested loops within the `check` function can contribute to O(n^2) in the worst case.
    *   Storage Complexity: O(n) for storing the potential `arr`.

	
	# Code
	```python
	def recover_array(nums):
    nums.sort()
    n = len(nums) // 2

    def check(first_lower):
        k = -1
        for j in range(1, 2 * n):
            potential_k = (nums[j] - first_lower) // 2
            if (nums[j] - first_lower) % 2 == 0 and potential_k > 0:
                k = potential_k
                break
        
        if k == -1:
            return None
        
        lower = []
        higher = []
        arr = []
        counts = {}
        for num in nums:
            counts[num] = counts.get(num, 0) + 1

        lower.append(first_lower)
        counts[first_lower] -= 1
        
        for _ in range(n - 1):
            found_pair = False
            for num in nums:
                if counts.get(num,0) > 0 and num > lower[-1]:
                    if (num - lower[-1]) % 2 == 0 and (num - lower[-1])//2 == k :
                        
                        lower.append(lower[-1] + 2*k)
                        counts[lower[-1]] -= 1
                        found_pair = True
                        break
            if not found_pair:
              return None

        
        for val in lower:
          arr.append(val + k)
        
        
        potential_lower = []
        potential_higher = []
        
        for val in arr:
          potential_lower.append(val-k)
          potential_higher.append(val+k)
        
        combined = potential_lower + potential_higher
        combined.sort()

        if combined == nums:
            return arr
        else:
          return None

    for i in range(n):
        result = check(nums[0])
        if result:
            return result

    return None
	```