O espaço x de um conjunto de números inteiros é o conjunto de todos os números inteiros que podem ser obtidos combinando os números inteiros iniciais com o operador xor bit a bit usual ( ^). Por exemplo, o xorspace de (8, 4)é (0, 4, 8, 12): 0 é 4 ^ 4, 12 é 4 ^ 8 e nenhum outro número pode ser alcançado. Observe que os números iniciais são sempre incluídos, por esta definição (por exemplo, 4 é 4 ^ 4 ^ 4).

Seu objetivo é escrever o programa mais curto que recebe uma lista de números inteiros não negativos como entrada e gera o número de elementos em seu espaço x.

• As brechas padrão são proibidas.
• A entrada e a saída podem estar em qualquer um dos formatos usuais . A entrada é garantida como válida, não vazia e sem duplicatas.
• Seu código deve poder processar todos os casos de teste em menos de um dia .

Casos de teste

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

Pitão, 8 bytes

lu{+xM*Q

Suíte de teste

Explicação:

Para gerar o xorspace, encontramos o ponto de correção de pegar o xor de cada par de números, adicionar cada número e deduplicar. Então, tomamos a duração do resultado. Isso é executado em 20 segundos (apenas offline) no caso de teste final.

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.

Pacote Pyth , 7 bytes

Hexdump:

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

O mesmo que o acima, com uma codificação ASCII de 7 bits.

Coloque o acima em um arquivo com xxd -re execute-o da seguinte maneira:

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

MATL , 11 bytes

t"G!Z~Ghu]n

Experimente online!

O último caso de teste não é executado no interpretador online devido a limitações de memória, mas é executado offline em menos de 2 segundos em um computador moderno.

Explicação

Para entrada de tamanho n, faça o seguinte:

1. Inicialize o resultado para entrada.
2. nTempos de repetição :
   1. Aplique o XOR bit a bit a todos os pares de entradas do resultado e da entrada atuais.
   2. Anexe valores de entrada ao resultado.
   3. Desduplicar.
3. A saída é o número de elementos do resultado final.

Código comentado.

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

Exemplo

Os resultados intermediários (etapas 2.1 e 2.3) para entrada [256 259 3]são:

Primeira iteração: [256 259 3]com [256 259 3]: computar todos os pares de bit a bit-XOR fornece à matriz

  0   3 259
  3   0 256
259 256   0

Anexando [256 259 3]e desduplicando

0 3 259 256

Segunda iteração: resultado atual [0 3 259 256]com [256 259 3]. Depois de deduplicar isso novamente,

0 3 259 256

Terceira iteração: novamente

0 3 259 256

Portanto, a saída é 4(número de entradas do resultado).

Haskell , 64 bytes

f pega uma lista de números inteiros e retorna um número inteiro.

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

Experimente online!

Isso não lida com uma lista vazia, pois você pode, mas em $0:vez do espaço apósmaximum .

Como funciona

• Se o valor máximo m da lista for zero, retornará 1.
• Caso contrário, xors todos os elementos com o máximo.
  • Se o resultado for menor que o elemento, o elemento será substituído por ele.
  • Isso necessariamente zera o bit mais significativo definido em qualquer lugar da lista.
  • Em seguida, recursa na lista resultante, dobrando o resultado da recursão.
• Esse processo executa essencialmente a eliminação gaussiana (embora jogue fora as linhas finais definindo-as como 0) módulo 2, na matriz cujas linhas são as representações de bits da lista de números. O conjunto de representações de bits do "xorspace" é o módulo de espaço vetorial 2 estendido pelas linhas desta matriz e cujo número de elementos é 2 à potência da classificação de linha da matriz.
• Esse algoritmo é tempo polinomial, portanto deve ser definitivamente melhor que O (2 ^ n).

Mathematica, 52 bytes

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

05AB1E , 8 bytes

vDy^ìÙ}g

Experimente online!

Todos os casos de teste terminam em menos de 1 minuto no TIO.

Python 2 , 55 bytes

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

Experimente online!

Bate para fora funções:

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}))

O belo método de eliminação de linhas de Ørjan Johansen é um byte mais curto.

Python 2 , 54 bytes

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

Experimente online!

Geléia , 9 8 bytes

0œ|⁺^¥/L

Conclui todos os casos de teste em menos de 8 segundos no TIO, com requisitos de memória insignificantes.

Experimente online!

Como funciona

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 bytes

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)