一组整数的xorspace是所有整数的集合，可以通过将起始整数与通常的按位xor运算符（^）组合获得。例如，x的xorspace (8, 4)是(0, 4, 8, 12)：0是4 ^ 4，12 是4 ^ 8，并且没有其他数字可以达到。请注意，根据此定义，始终包括起始编号（例如4为4 ^ 4 ^ 4）。

您的目标是编写最短的程序，该程序将非负整数列表作为输入，并输出其xorspace中的元素数量。

• 禁止出现标准漏洞。
• 输入和输出可以采用任何常用格式。输入内容被保证为有效，非空且没有重复。
• 您的代码应该能够在不到一天的时间内处理所有测试用例。

测试用例

Input: 0
Output: 1

Input: 6
Output: 2

Input: 8 4
Ouput: 4

Input: 0 256
Output: 2

Input: 256 259 3
Output: 4

Input: 60 62 94 101 115
Output: 32

Input: 60 62 94 101 115 40 91
Output: 32

Input: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
Output: 64

Input: 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384
Output: 32768

Pyth，8个字节

lu{+xM*Q

测试套件

说明：

为了生成异或空间，我们找到了对每个数字进行异或，添加每个数字并进行重复数据删除的固定点。然后，我们计算结果的长度。在最终测试用例上，此过程需要20秒（仅离线）。

lu{+xM*Q
lu{+xM*QGGQ    Implicit variable introduction
 u        Q    Find the fixed point of the following, starting with the input,
               where the current value is G.
      *QG      Form the Cartesian product of Q (input) and G (current)
    xM         Take the xor of every pair
   +           Add the current values
  {            Deduplicate
l              Output the length of the result.

装箱的腐肉，7个字节

十六进制转储：

0000000: d9d7 dabf 1355 51                        .....UQ

与上述相同，使用7位ASCII编码。

将以上内容放入带有的文件中xxd -r，然后按以下方式运行：

py packed-pyth.py xorspace.ppyth '[256, 259, 3]'

MATL，11个字节

t"G!Z~Ghu]n

在线尝试！

由于内存限制，最后一个测试用例不在联机解释器中运行，但是在现代计算机上，脱机运行不到2秒。

说明

输入尺寸 n，它执行以下操作：

1. 初始化结果以输入。
2. 重复 n次数：
   1. 对当前结果和输入中的所有条目对按位进行XOR。
   2. 将输入值附加到结果。
   3. 重复数据删除。
3. 输出是最终结果的元素数。

注释代码。

t      % Implicit input: row vector. Duplicate
"      % For each (i.e. do as many times as the input size)
  G!   %   Push input as a column vector
  Z~   %   Bitwise XOR with broadcast, i.e. for all pairs of entries of the
       %   two arguments. The first argument is the accumulated result
       %   from the previous iteration, the second is the input vector
  G    %   Push input again
  h    %   Postpend
  u    %   Unique values. Gives a row vector
]      % End
n      % Number of entries. Implicitly display

例

输入的中间结果（步骤2.1和2.3） [256 259 3]：

第一次迭代：[256 259 3]使用[256 259 3]：计算所有按位异或对，得出矩阵

  0   3 259
  3   0 256
259 256   0

附加[256 259 3]和重复数据删除

0 3 259 256

第二次迭代：当前的结果[0 3 259 256]与[256 259 3]。重复数据删除后，这再次给出

0 3 259 256

第三次迭代：再次

0 3 259 256

因此输出为4（结果的条目数）。

Haskell，64个字节

f 接受一个整数列表并返回一个整数。

import Data.Bits
f l|m<-maximum l,m>0=2*f(min<*>xor m<$>l)|0<1=1

在线尝试！

这不会处理一个空列表，因为您可以，但是可以$0:代替后面的空格maximum。

怎么运行的

• 如果最大 m列表为零，则返回1。
• 否则，将具有最大值的每个元素异或。
  • 如果结果小于元素，则将其替换为元素。
  • 这必然会将列表中任何位置的最高有效位置零。
  • 然后在结果列表上递归，将递归的结果加倍。
• 此过程实质上执行高斯消除在矩阵的行是数字列表的位表示形式的矩阵（尽管通过将最后的行设置为0抛弃最后的行）。“ xorspace”的位表示的集合是该矩阵的行跨越的模空间为2的向量空间，其元素数量为矩阵行秩的幂的2。
• 该算法是多项式时间，因此绝对应优于O（2 ^ n）。

Mathematica，52个字节

2^MatrixRank[PadLeft@IntegerDigits[#,2],Modulus->2]&

05AB1E，8个字节

vDy^ìÙ}g

在线尝试！

在TIO上，所有测试用例均在1分钟内完成。

Python 2，55个字节

r={0}
for n in input():r|={x^n for x in r}
print len(r)

在线尝试！

击败功能：

f=lambda l,r={0}:l and f(l[1:],r|{x^l[0]for x in r})or len(r)
f=lambda l:len(reduce(lambda r,n:r|{x^n for x in r},l,{0}))

ØrjanJohansen的漂亮行消除方法短了一个字节。

Python 2，54个字节

f=lambda l:1-any(l)or 2*f([min(x,x^max(l))for x in l])

在线尝试！

果冻，9 8字节

0œ|⁺^¥/L

在TIO上不到8秒的时间内完成所有测试用例，而对内存的需求却可以忽略不计。

在线尝试！

怎么运行的

0œ|⁺^¥/L  Main link. Argument: A (array)

0œ|       Perform multiset union with 0, prepending 0 if A doesn't contain it.
      /   Reduce A by the link to the left.
     ¥      Combine the previous two links into a dyadic chain.
            Left argument: V (array). Right argument: n (integer)
    ^           Bitwise XOR each element in V with n.
   ⁺            This quick refers to the previous link, making it a shorthand for
                the link 'œ|'. Thus, it performs multiset union on V and the array
                of bitwise XORs.
       L  Compute the length of the result.

Python，113个字节

def f(x):
 u,s=[0],{0}
 while u:
	a=u.pop()
	for b in x:
	 c=a^b
	 if c not in s:u+=[c]
	 s.add(c)
 return len(s)