# Solving Leetcode Interviews in Seconds with AI: Relative Sort Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1122" 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 two arrays arr1 and arr2, the elements of arr2 are distinct, and all elements in arr2 are also in arr1. Sort the elements of arr1 such that the relative ordering of items in arr1 are the same as in arr2. Elements that do not appear in arr2 should be placed at the end of arr1 in ascending order.   Example 1:  Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6] Output: [2,2,2,1,4,3,3,9,6,7,19]  Example 2:  Input: arr1 = [28,6,22,8,44,17], arr2 = [22,28,8,6] Output: [22,28,8,6,17,44]    Constraints:  1 <= arr1.length, arr2.length <= 1000 0 <= arr1[i], arr2[i] <= 1000 All the elements of arr2 are distinct. Each arr2[i] is in arr1.  

	# Explanation
	Here's an efficient solution to the problem, along with explanations:

*   **Frequency Counting:** Use a hash map (dictionary in Python) to count the occurrences of each element in `arr1`. This allows O(1) access to the frequency of each number.
*   **Ordered Placement:** Iterate through `arr2`. For each element in `arr2`, append it to the result array the number of times it appears in `arr1` (based on the frequency counts). Simultaneously, remove these elements from the frequency map.
*   **Remaining Elements:**  The remaining elements in the frequency map are those not present in `arr2`. Sort these elements and append them to the result array.

*   **Runtime Complexity:** O(n + m log k), where n is the length of `arr1`, m is the length of `arr2`, and k is the number of distinct elements in `arr1` but not in `arr2`. This arises from iterating through both arrays and the sorting of remaining elements. Storage Complexity: O(n), due to the frequency map.

	
	# Code
	```python
	def relative_sort_array(arr1, arr2):
    """
    Sorts arr1 according to the relative ordering of arr2,
    placing elements not in arr2 at the end in ascending order.
    """

    counts = {}
    for x in arr1:
        counts[x] = counts.get(x, 0) + 1

    result = []
    for y in arr2:
        if y in counts:
            result.extend([y] * counts[y])
            del counts[y]

    remaining = sorted(counts.keys())
    for z in remaining:
        result.extend([z] * counts[z])

    return result
	```