Calcola la sequenza binaria del triangolo Sierpinski


23

La sequenza del triangolo binario di Sierpinski è la sequenza di numeri le cui rappresentazioni binarie danno le righe del triangolo binario di Sierpinski, che viene dato iniziando con un 1 in una fila infinita di zero, quindi sostituendo ripetutamente ogni coppia di bit con lo xor di quei bit , così:

f(0)=      1                    =1
f(1)=     1 1                   =3
f(2)=    1 0 1                  =5
f(3)=   1 1 1 1                 =15
f(4)=  1 0 0 0 1                =17

Altre cifre sono fornite a OEIS: https://oeis.org/A001317

Input: un numero intero non negativo n in qualsiasi formato desiderato. (Deve funzionare per tutti i n fino a 30.)

Output: l'ennesimo termine (indicizzato 0) della sequenza come un numero decimale.

Questo è quindi prova a dare la risposta più breve in byte di cui la tua lingua è capace. Nessuna risposta sarà accettata. Si applicano scappatoie standard (ad es. Nessuna codifica definitiva della sequenza), tranne per il fatto che è possibile utilizzare una lingua creata / modificata dopo la pubblicazione della sfida. (Evitare di pubblicare un'altra soluzione in una lingua che è già stata utilizzata a meno che la soluzione non sia più corta.)

Classifica

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes


8
Non sono un grande fan di non dover emettere una risposta sbagliata per nessun n . Questo in pratica forza le lingue che non usano numeri interi di precisione arbitraria per impostazione predefinita per verificare se l'input è abbastanza piccolo ...
Dennis,

Si prega di chiarire se le regole sono state comprese correttamente (vedere i commenti qui e qui ) e se l'output arrotondato (ad es. 1.288490189e10 per l'ingresso 33) viene considerato errato .
Dennis,

"Deve funzionare per tutti i n fino a 30 e non deve generare una risposta errata per nessun n." . Questo è contraddittorio - sicuramente "non deve dare una risposta sbagliata" è lo stesso di "Deve funzionare" ???
Trauma digitale il

5
A causa della schiacciante opposizione popolare al carico irragionevole e schiacciante dell'anima della convalida dell'input, questo requisito è stato rimosso. È possibile produrre qualsiasi immondizia che si desidera per n grande. Godere!
Quintopia,

2
Piuttosto che dire che l'output non dovrebbe essere sbagliato, raccomanderei solo di dire che i contributi devono supportare input fino al più grande nper il quale nulla trabocca.
Alex A.

Risposte:


14

05AB1E , 5 4 byte

Vi presento con orgoglio, 05AB1E. Sebbene sia molto corto, probabilmente è molto brutto nelle lunghe sfide.

Grazie a ETHproductions per la rasatura di 1 byte :)

$Fx^

Spiegazione:

$      # Pushes 1 and input
 F     # Pops x, creates a for-loop in range(0, x)
  x    # Pops x, pushes x and 2x
   ^   # Bitwise XOR on the last two elements
       # Implicit, ends the for-loop
       # Implicit, nothing has printed so the last element is printed automatically

Sai, un buon modo per escludere un byte da molti programmi in un linguaggio personalizzato è quello di }inserire automaticamente un trailing . Quindi questo sarebbe di 4 byte. :)
Produzioni ETH il

1
@ETHproductions Aspetta un attimo, che è già stato implementato :). Grazie per aver rasato 1 byte ahah.
Adnan,

2
C'è un bug in questo codice. Come lo so? Sta battendo Dennis.
Arcturus,

2
@Ampora Non solo sta battendo Dennis, ma sta battendo il linguaggio del golf personalizzato di Dennis. ;)
ETHproductions il

@Adnan Wow. Stai per qualcosa.
RK.

12

Pari / GP , 27 byte

n->lift(Mod(x+1,2)^n)%(x-2)

La funzione prende l'ennesima potenza del polinomio x + 1 nell'anello F 2 [x], la solleva su Z [x] e la valuta in 2.

Provalo online!


6

Gelatina , 6 byte

1Ḥ^$³¡

Provalo online!

La versione binaria che funziona con questa revisione dell'interprete Jelly ha il dump xxd

0000000: 31 a8 5e 24 8b 80  1.^$..

Come funziona

1Ḥ^$³¡    Input: n

1         Set the left argument to 1.
 Ḥ        Multiple the left argument by two.
  ^       Hook; XOR it with its initial value.
   $      Create a monadic chain from the last two insructions.
    ³¡    Call the chain n times, updating the left argument after each call.

5

Haskell, 44 byte

import Data.Bits
f n=iterate((2*)>>=xor)1!!n

Nella ((->) r)monade, (f >>= g) xuguale g (f x) x.


Penso che puoi rendere anonimo l'ultima riga a(iterate((2*)>>=xor)1!!)
xnor

Ci ho provato, ma non funziona, per temuti motivi di restrizione al monomorfismo .
Lynn il

Tuttavia, ciò potrebbe applicarsi come espressione legale, poiché la limitazione del monomorfismo non si applica alle espressioni, ma alle dichiarazioni. E le espressioni sono considerate risposte legali, se non sbaglio.
orgoglioso haskeller

4

Matlab, 45 byte

Soluzione:

@(i)2.^[0:i]*diag(mod(fliplr(pascal(i+1)),2))

Test:

ans(10)
ans =
1285

Spiegazione: pascalcostruisce il triangolo di Pascal, ma inizia da 1, quindi l'input dovrebbe essere i+1. fliplrinverte l'array da sinistra a destra. mod(_,2)prende il resto dopo la divisione per 2. diagestrae la diagonale principale. Moltiplicazione usando il 2.^[0:i]vettore converte in decimale

Sono contento, @flawr di aver trovato qui il concorrente Matlab :)


Sembra funzionare anche con Octave.
Dennis,

4

JavaScript (ES6), 23 byte

f=x=>x?(y=f(x-1))^y*2:1

Basato sulla prima formula nella pagina OEIS. Se non ti dispiace che il codice impieghi quasi un'eternità per finire per un input di 30, possiamo radere via un byte:

f=x=>x?f(--x)^f(x)*2:1

Ecco una versione non ricorsiva, usando un forciclo in un eval: (32 byte)

x=>eval("for(a=1;x--;a^=a*2);a")

Le regole, come attualmente scritte, invalidano questa risposta, poiché f(35)restituisce 15. Inoltre, avviso bomba a forcella: ho dovuto forzare la chiusura di Chromium per fermare f(30)(revisione originale) dalla corsa. : P
Dennis,

1
@Dennis Aspetta, quindi se non riesco a produrre alcun valore errato, cosa dovrei fare con input superiori a 30?
Produzioni ETH il

Non sono sicuro (e spero che la regola venga cambiata ), ma qualcosa del genere f=x=>x?(y=f(x-(x<31)))^y*2:1funzionerebbe.
Dennis,

@Dennis Ah, recurse infinitamente = nessuna uscita. Risolverò questo quando torno sul mio computer. Spero che anche questa regola venga cambiata.
Produzioni ETH il

La regola è stata rimossa dalla domanda.
Dennis,

3

Matlab, 77 70 byte

Questa funzione calcola l'ennesima riga del triangolo di Pascal tramite una convoluzione ripetuta con [1,1](ovvero espansione binomiale o moltiplicazione ripetuta con un binomio) e calcola il numero da quella.

function r=c(n);k=1;for i=1:n;k=conv(k,[1,1]);end;r=2.^(0:n)*mod(k,2)'

3

Rubino, 26 byte

funzione anonima con iterazione.

->n{a=1;n.times{a^=a*2};a}

questa funzione ricorsiva è più corta di un byte, ma poiché deve essere denominata per poter fare riferimento a se stessa, finisce un byte in più.

f=->n{n<1?1:(s=f[n-1])^s*2}

3

Rubino, 25 byte

->n{eval"n^=2*"*n+?1*n=1}

Fino ad ora più brevi delle altre risposte qui. Costruisce questa stringa:

n^=2*n^=2*n^=2*n^=2*1

Quindi imposta n=1(ciò accade effettivamente mentre viene creata la stringa) e valuta la stringa sopra, restituendo il risultato.


Fa *n=1davvero risparmiare qualcosa di piùm=1;"m^=2*"*n+?1
Martin Ender il

No, ma farlo con una sola variabile è molto appariscente :)
Lynn il

3

Samau , 4 byte

Ora Samau ha funzioni integrate per la moltiplicazione XOR e la potenza XOR.

▌3$ⁿ

Dump esadecimale (Samau utilizza la codifica CP737):

dd 33 24 fc

Spiegazione:

▌       read a number
 3      push 3
  $     swap
   ⁿ    take the XOR power

Questo potrebbe essere ridotto a 3 byte scambiando i primi due comandi ed eliminando lo scambio?
Quintopia,

@quintopia No. Samau inserisce automaticamente l'input nello stack come una stringa e legge un numero dalla stringa. Se scambiamo i primi due comandi, proverebbe a leggere un numero 3, che non è una stringa.
alephalpha,

perché samau non prova a valutare la corda quando possibile?
Quintopia,


2

Pure Bash (senza utility esterne), 37

Gli interi di Bash sono firmati a 64 bit, quindi funziona per input fino a 62 inclusi:

for((x=1;i++<$1;x^=x*2)){
:
}
echo $x

2

Python 2.7.6, 38 33 byte

Grazie a Dennis per essersi rasato qualche byte!

x=1
exec'x^=x*2;'*input()
print x

1
Benvenuto in Programmazione di puzzle e codice golf! exec'x^=x*2;'*input()salva alcuni byte forsull'approccio.
Dennis,

Questo batte la mia voce su Python, che lascerò qui per i posteri:f=lambda n:f(n-1)^2*f(n-1)if n>0 else 1
Jack Brounstein il

2

Pyth, 7 byte

uxyGGQ1

Provalo online: dimostrazione

Spiegazione:

u    Q1   apply the following statement input-times to G=1:
 xyGG        update G with (2*G xor G)


2

MIPS, 28 byte

Ingresso in $a0, uscita in $v0.

0x00400004  0x24020001          li      $v0, 1
0x00400008  0x10800005  loop:   beqz    $a0, exit
0x0040000c  0x00024021          move    $t0, $v0
0x00400010  0x00021040          sll     $v0, $v0, 1
0x00400014  0x00481026          xor     $v0, $v0, $t0
0x00400018  0x2084ffff          addi    $a0, $a0, -1
0x0040001c  0x08100002          j       loop


1

k4, 26 byte

{x{2/:~(=). 0b\:'1 2*x}/1}

0b\:converte un numero in un vettore booleano (vale a dire la stringa di bit), XOR viene implementato come "non uguale", 2/:converte una stringa di bit in un numero trattandolo come un polinomio da valutare e x f/ycon xun numero intero viene fapplicato yprima a, e poi al suo xtempi di uscita successivi .

Esecuzione di esempio:

  {x{2/:~(=). 0b\:'1 2*x}/1}'!5                                                                                                                                                                                    
1 3 5 15 17

1

Rubino, 31 26 byte

EDIT: cambiato completamente in un'altra lingua! Tutti i suggerimenti per il golf sono benvenuti!

Questo programma XOR bit per bit l'elemento precedente della sequenza con il doppio stesso, vale a dire f(n) = f(n-1) ^ 2*f(n-1).

->n{v=1;n.times{v^=2*v};v}

1

MATL , 15 byte

Simile alla risposta di @ flawr :

i:1w"TToX+]2\XB

EDIT (20 maggio 2016) Provalo online! con X+sostituito daY+ per conformarsi alla versione 18.0.0 della lingua.

Esempio

>> matl i:1w"TToX+]2\XB
> 5
51

Spiegazione

i              % input                                                     
:              % vector of values 1, 2, ... to previous input                           
1              % number literal                                            
w              % swap elements in stack                                    
"              % for                                                       
    TTo        % vector [1 1]
    X+         % convolution                                               
]              % end                                                       
2\             % modulo 2
XB             % convert from binary to decimal              

1

Brainfuck , 87 byte

,[>>[>]++<[[->+>+<<]>-->[-<<+>>]<[>+<-[>-<-]]>+<<<]>>>[[-<+>]>]<<[<]<-]>>[<[->++<]>>]<+

Provalo online!

Presuppone celle di dimensioni infinite (altrimenti non può superare 7, che è convenientemente 255). Il metodo mod 2 del triangolo di Pascal è in realtà molto più lungo a causa della costosa operazione mod 2, mentre XOR è molto più facile da implementare.


0

APL, 31 byte

{({2⊥⊃~1 2=.{(64⍴2)⊤⍺×⍵}⍵}⍣⍵)1}

Questo è quasi certamente un codice terribile, ma sono un principiante APL completo. Mi aspetto che chiunque abbia qualche abilità possa sbarazzarsi di tutte le funzioni D e accorciarlo considerevolmente. La logica è più o meno la stessa della mia k4risposta: moltiplicare per 1o 2, convertire in bit con , XOR usando non uguale, convertire indietro in un numero con , avvolgere il tutto in una funzione e chiedere un numero specifico di iterazioni usando . Non ho idea del perché il risultato che esce dal prodotto interno sia racchiuso, ma lo pulisce.


Dovresti essere in grado di salvare un byte cambiando ~1 2=.in1 2≠.
Zacharý

E su quale sistema APL è attivo? Se è su Dyalog, dovresti riuscire a farcela {({2⊥⊃1 2≠.((64⍴2)⊤×)⍵}⍣⍵)1}[28 byte]
Zacharý,

0

Scherzi a parte, 12 byte

2,╣`2@%`Mεj¿

Dump esadecimale:

322cb960324025604dee6aa8

Provalo online

Dal momento che Seriamente non include alcun mezzo per eseguire uno xor bit per bit, questa soluzione prende la sfida completamente alla lettera, calcolando direttamente la riga del triangolo. Questo metodo fornisce risposte corrette fino a n = 1029 (dopo di che non c'è memoria sufficiente per calcolare la riga data del triangolo di Pascal).

Spiegazione:

 ,                       get input
  ╣                 push the nth row of pascal's triangle
   `2@%`M           take each element of the row mod 2
         εj         join all the binary digits into a string
2          ¿        interpret it as a base 2 number

0

Pyt , 40 10 byte

Đ0⇹Řć2%ǰ2Ĩ

Spiegazione:

Osservando che il triangolo binario di Sierpinski è equivalente al triangolo di Pascal mod 2,

                      Implicit input
Đ                     Duplicate input
 0⇹Ř                  Push [0,1,2,...,input]
    ć2%               Calculate the input-th row of Pascal's Triangle mod 2
       ǰ              Join elements of the array into a string
        2Ĩ            Interpret as a binary number
                      Implicit print

Provalo online!


Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.