# Solving Leetcode Interviews in Seconds with AI: Array of Doubled Pairs


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "954" 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
	> Given an integer array of even length arr, return true if it is possible to reorder arr such that arr[2 * i + 1] = 2 * arr[2 * i] for every 0 <= i < len(arr) / 2, or false otherwise.   Example 1:  Input: arr = [3,1,3,6] Output: false  Example 2:  Input: arr = [2,1,2,6] Output: false  Example 3:  Input: arr = [4,-2,2,-4] Output: true Explanation: We can take two groups, [-2,-4] and [2,4] to form [-2,-4,2,4] or [2,4,-2,-4].    Constraints:  2 <= arr.length <= 3 * 104 arr.length is even. -105 <= arr[i] <= 105  

	# Explanation
	Here's an efficient solution to determine if an array can be reordered according to the given condition:

*   **Frequency Counting:** Use a dictionary (or `Counter`) to store the frequency of each number in the input array.
*   **Iterative Matching:** Iterate through the sorted keys of the frequency map. For each number `x`, check if `2 * x` exists in the map and if their frequencies allow for pairing. Handle zero separately.
*   **Zero Handling:** Special handling for zero because 2*0 = 0, if the count of zeros are odd, then return `False`.

*   **Runtime Complexity:** O(n log n), where n is the length of the array, due to sorting the keys of the frequency map.
*   **Storage Complexity:** O(n) in the worst case, to store the frequency map.

	
	# Code
	```python
	from collections import Counter

def canReorderDoubled(arr):
    """
    Determines if an array can be reordered such that arr[2 * i + 1] = 2 * arr[2 * i]
    for every 0 <= i < len(arr) / 2.

    Args:
        arr: An integer array of even length.

    Returns:
        True if it is possible to reorder arr as described, False otherwise.
    """
    counts = Counter(arr)
    for x in sorted(counts.keys(), key=abs):
        if counts[x] == 0:
            continue
        if counts[2 * x] < counts[x]:
            return False
        counts[2 * x] -= counts[x]
        counts[x] = 0
    return True
	```