Lo spazio x di un insieme di numeri interi è l'insieme di tutti i numeri interi che è possibile ottenere combinando i numeri interi iniziali con il solito operatore xor bit a bit ( ^). Ad esempio, lo spazio x di (8, 4)è (0, 4, 8, 12): 0 è 4 ^ 4, 12 è 4 ^ 8 e non è possibile raggiungere altri numeri. Si noti che i numeri iniziali sono sempre inclusi, con questa definizione (ad esempio, 4 è 4 ^ 4 ^ 4).

Il tuo obiettivo è quello di scrivere il programma più breve che accetta come input un elenco di numeri interi non negativi e genera il numero di elementi nel loro spazio x.

• Sono vietate le scappatoie standard .
• L'input e l'output possono essere in uno dei normali formati . L'immissione è garantita come valida, non vuota e senza duplicati.
• Il codice dovrebbe essere in grado di elaborare tutti i casi di test in meno di un giorno .

Casi test

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 byte

lu{+xM*Q

Suite di test

Spiegazione:

Per generare lo xorspace, troviamo il punto fisso di prendere l'xor di ogni coppia di numeri, aggiungere ogni numero e deduplicare. Quindi prendiamo la lunghezza del risultato. Viene eseguito in 20 secondi (solo offline) sul caso di test finale.

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.

Pyth confezionato , 7 byte

hexdump:

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

Come sopra, con una codifica ASCII a 7 bit.

Inserisci quanto sopra in un file con xxd -red eseguilo come segue:

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

MATL , 11 byte

t"G!Z~Ghu]n

Provalo online!

L'ultimo test case non viene eseguito nell'interprete online a causa delle limitazioni di memoria, ma viene eseguito offline in meno di 2 secondi su un computer moderno.

Spiegazione

Per l'immissione della dimensione n, ciò procede come segue:

1. Inizializza il risultato da inserire.
2. Ripetere n tempi:
   1. Applica XOR bit a bit a tutte le coppie di voci dal risultato e dall'input correnti.
   2. Allega valori di input al risultato.
   3. Deduplicazione.
3. L'output è il numero di elementi del risultato finale.

Codice commentato.

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

Esempio

I risultati intermedi (passaggi 2.1 e 2.3) per l'input [256 259 3] sono:

Prima iterazione: [256 259 3]con [256 259 3]: calcolare tutte le coppie di bitwise-XOR dà la matrice

  0   3 259
  3   0 256
259 256   0

Allegare [256 259 3]e deduplicare

0 3 259 256

Seconda iterazione: risultato attuale [0 3 259 256]con [256 259 3]. Dopo aver deduplicato questo dà di nuovo

0 3 259 256

Terza iterazione: di nuovo

0 3 259 256

Quindi l'output è 4(numero di voci del risultato).

Haskell , 64 byte

f accetta un elenco di numeri interi e restituisce un numero intero.

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

Provalo online!

Questo non gestisce un elenco vuoto, per quello che puoi ma al $0:posto dello spazio dopomaximum .

Come funziona

• Se il massimo m dell'elenco è zero, restituisce 1.
• Altrimenti, xorizza ogni elemento con il massimo.
  • Se il risultato è più piccolo dell'elemento, l'elemento viene sostituito da esso.
  • Questo azzera necessariamente il bit più significativo impostato in qualsiasi punto dell'elenco.
  • Quindi recluta nell'elenco risultante, raddoppiando il risultato della ricorsione.
• Questo processo esegue essenzialmente l' eliminazione gaussiana (sebbene buttando via le righe finali impostandole su 0) modulo 2, sulla matrice le cui righe sono rappresentazioni di bit dell'elenco di numeri. L'insieme delle rappresentazioni dei bit dello "xorspace" è lo spazio vettoriale modulo 2 attraversato dalle righe di questa matrice e il cui numero di elementi è 2 rispetto alla potenza del rango di riga della matrice.
• Questo algoritmo è un tempo polinomiale, quindi dovrebbe sicuramente essere migliore di O (2 ^ n).

Mathematica, 52 byte

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

05AB1E , 8 byte

vDy^ìÙ}g

Provalo online!

Tutti i casi di test terminano in meno di 1 minuto su TIO.

Python 2 , 55 byte

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

Provalo online!

Batte le funzioni:

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

Il bellissimo metodo di eliminazione delle righe di Ørjan Johansen è più corto di un byte.

Python 2 , 54 byte

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

Provalo online!

Gelatina , 9 8 byte

0œ|⁺^¥/L

Termina tutti i casi di test in meno di 8 secondi su TIO, con requisiti di memoria trascurabili.

Provalo online!

Come funziona

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 byte

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)