用给定的Sum和XOR构造最小的数组

给定两个数字sum和xor，找到一个由不同正整数构成的最小数组，其中数组元素的总和等于sum，数组元素的异或总和等于xor。

例如，当sum=6且xor=5时，可以构造出数组[1,2,3]，因为1 XOR 2 XOR 3 = 0b01 XOR 0b10 XOR 0b11 = 0b00 = 0。此时数组的总和为1+2+3=6。

下面我们来讨论如何解决这个问题。

分析

我们可以通过以下的方法来构造这个数组：

1. 将xor分解成二进制形式，得到一个由若干个1和0组成的二进制串。
2. 从高位到低位依次处理二进制串中的每一位，如果该位上是1，则将一个数加入到数组中，并且该数的二进制表示中对应的那一位也是1。否则，将一个数加入到数组中，并且该数的二进制表示中对应的那一位是0。
3. 最后，将剩余的数字按从小到大的顺序加入到数组中，以保证数组元素的总和等于sum。

代码

下面是使用Python编写的实现代码片段，其中solution()函数用于解决上述问题：

def solution(sum: int, xor: int) -> List[int]:
    if sum < xor or (sum - xor) % 2 != 0:
        # 无解情况
        return []
    
    # 将xor分解成二进制形式
    digits = []
    while xor > 0:
        digits.append(xor % 2)
        xor //= 2
    digits.reverse()
    
    # 构造数组
    result = []
    bit = 30  # 由于sum和xor最大为2^30，因此最多只有30个二进制位
    carry = 0
    while bit >= 0:
        if carry == 1:
            result.append(2 ** bit)
        elif len(digits) > 0 and digits[0] == 1:
            result.append(2 ** bit)
            digits.pop(0)
            carry = 1
        else:
            carry = 0
        bit -= 1
    
    # 添加剩余的数字
    n = sum - sum(result)
    for i in range(1, n + 1):
        if i != (n ^ i):
            result.append(i)
    return result

在此代码中，我们首先判断了是否有解的情况。如果sum小于xor或者它们的差是奇数，则无解。否则，我们将xor分解成二进制形式，并从高位到低位依次构造数组。最后，将剩余的数字按从小到大的顺序加入到数组中。

性能分析

由于我们只遍历了二进制串中的每一位，因此时间复杂度为$O(\log\text{xor})$。空间复杂度为$O(\log\text{xor})$，其中由于我们使用了一个列表来存储二进制串，因此空间复杂度会略高一些。

from typing import List

def solution(sum: int, xor: int) -> List[int]:
    """
    Construct an array of positive integers with minimum length whose sum is `sum` and xor is `xor`.

    Args:
        sum: An integer indicating the desired sum.
        xor: An integer indicating the desired xor.

    Returns:
        A list of positive integers that meets the requirements.

        If no such array can be constructed, an empty list will be returned.
    """
    if sum < xor or (sum - xor) % 2 != 0:
        # The case where there is no solution
        return []

    # Decompose `xor` into a binary string
    digits = []
    while xor > 0:
        digits.append(xor % 2)
        xor //= 2
    digits.reverse()

    # Construct the array
    result = []
    bit = 30  # Since `sum` and `xor` are at most 2^30, there are at most 30 binary digits
    carry = 0
    while bit >= 0:
        if carry == 1:
            result.append(2 ** bit)
        elif len(digits) > 0 and digits[0] == 1:
            result.append(2 ** bit)
            digits.pop(0)
            carry = 1
        else:
            carry = 0
        bit -= 1

    # Add the remaining numbers
    n = sum - sum(result)
    for i in range(1, n + 1):
        if i != (n ^ i):
            result.append(i)
    return result