Advantage Shuffle - Leetcode Solution

The Advantage Shuffle problem on LeetCode asks us to rearrange a given array of integers nums in such a way that for every i, nums[i] is assigned to either the first or second array. The goal is to maximize the score of the first array by taking the sum of all its elements.

This can be done by sorting both the arrays nums and B, and then iterating through A and B simultaneously. At each step, we compare the current elements of both arrays and assign the larger element to the first array, and the smaller element to the second array. This ensures that the first array has the largest possible elements.

If there are any elements in the first array that are larger than all the elements in the second array, we can simply append them to the end of the first array. This ensures that we maximize the score of the first array.

The implementation can be achieved using two pointers, one for the first array and another for the second array. We first sort the arrays, and then iterate over them simultaneously using the pointers. At each step, we check whether the current element in the first array is greater than the current element in the second array. If it is, we append it to the end of our result array. If it is not, we append the current element in the second array to the result array.

Here is the detailed solution:

def advantage_shuffle(nums: List[int], B: List[int]) -> List[int]:
    # sort the arrays
    nums.sort()
    # create a copy of B and sort it
    sorted_B = sorted(B)
    # create an empty result array
    result = []
    # create two pointers for nums and sorted_B
    i, j = 0, 0
    # iterate over nums and sorted_B simultaneously
    while i < len(nums) and j < len(sorted_B):
        # if the current element in nums is greater than the current element in sorted_B
        if nums[i] > sorted_B[j]:
            # append the current element in nums to the result array
            result.append(nums[i])
            # increment the pointer for nums
            i += 1
        else:
            # append the current element in sorted_B to the result array
            result.append(sorted_B[j])
            # increment the pointer for sorted_B
            j += 1
    # if there are any remaining elements in nums that are larger than all the elements in sorted_B
    # append them to the end of the result array
    while i < len(nums):
        result.append(nums[i])
        i += 1
    return result

The time complexity of this solution is O(nlogn) due to sorting the arrays. The space complexity of this solution is O(n) since we create a copy of B.

1