Calcular a sequência do triângulo binário de Sierpinski


23

A sequência do triângulo binário de Sierpinski é a sequência de números cujas representações binárias fornecem as linhas do triângulo binário de Sierpinski, que são dadas começando com 1 em uma linha infinita de zeros, substituindo repetidamente cada par de bits pelo xor desses bits , igual a:

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

Mais dígitos são fornecidos no OEIS: https://oeis.org/A001317

Entrada: Um número inteiro não negativo n em qualquer formato que você desejar. (Deve funcionar para todos os n até 30.)

Saída: o enésimo termo (indexado 0) da sequência como um número decimal.

Isso é então tente dar a resposta mais curta em bytes da qual seu idioma é capaz. Nenhuma resposta será aceita. As brechas padrão se aplicam (por exemplo, não codificam a sequência), exceto que você pode usar um idioma criado / modificado após o lançamento deste desafio. (Evite postar outra solução em um idioma que já tenha sido usado, a menos que sua solução seja mais curta.)

Entre os melhores

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet:

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


8
Eu não sou um grande fã de não deve produzir uma resposta errada para qualquer n . Isso basicamente força linguagens que não usam números inteiros de precisão arbitrários por padrão para verificar se a entrada é pequena o suficiente ...
Dennis

Esclareça se as regras foram entendidas corretamente (veja os comentários aqui e aqui ) e se a saída arredondada (por exemplo, 1.288490189e10 para a entrada 33) conta como incorreta .
Dennis

"Deve funcionar para todos os n até 30 e não deve gerar uma resposta errada para nenhum n." . Isso é auto-contraditório - certamente "não deve dar uma resposta errada" é o mesmo que "Deve funcionar" ???
Digital Trauma

5
Devido à oposição popular esmagadora ao ônus irracional e esmagador da validação de entrada, esse requisito foi removido. Você pode gerar o lixo que desejar para n grande. Apreciar!
quintopia 23/12/2015

2
Em vez de dizer que o resultado não deve estar errado, eu recomendaria apenas dizer que os envios devem oferecer suporte ao maior número npara o qual nada excede.
Alex A.

Respostas:


14

05AB1E , 5 4 bytes

Eu orgulhosamente apresento a você, 05AB1E. Embora seja muito curto, provavelmente é muito ruim em longos desafios.

Graças à ETHproductions por reduzir 1 byte :)

$Fx^

Explicação:

$      # 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

Você sabe, uma boa maneira de obter um byte de muitos programas em um idioma personalizado é }inserir automaticamente um final . Então isso seria 4 bytes. :)
ETHproductions

1
@ETHproductions Aguarde um momento, que já foi implementado :). Obrigado por remover 1 byte haha.
Adnan

2
Há um erro neste código. Como eu sei? Está batendo no Dennis.
Arcturus

2
@Ampora Não só está derrotando Dennis, mas também na linguagem de golfe personalizada de Dennis. ;)
ETHproductions

@Adnan Wow. Você está em algo.
RK.


6

Gelatina , 6 bytes

1Ḥ^$³¡

Experimente online!

A versão binária que funciona com esta revisão do interpretador Jelly possui o dxxx dump

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

Como funciona

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 bytes

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

Na ((->) r)mônada, (f >>= g) xé igual g (f x) x.


Eu acho que você pode anonimizar a última linha para(iterate((2*)>>=xor)1!!)
xnor

Eu tentei isso, mas não funciona, por temidas razões de restrição ao monomorfismo .
Lynn

No entanto, isso pode se aplicar como uma expressão legal, pois a restrição de monomorfismo não se aplica a expressões, mas a declarações. E expressões são consideradas respostas legais, se não me engano.
haskeller orgulhoso

4

Matlab, 45 bytes

Solução:

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

Teste:

ans(10)
ans =
1285

Explicação: pascalconstrói o triângulo Pascal, mas começa a partir de 1, portanto a entrada deve ser i+1. fliplrvira a matriz da esquerda para a direita. mod(_,2)toma o restante após a divisão por 2. diagextrai a diagonal principal. Multiplicação usando 2.^[0:i]converte vetor em decimal

Estou feliz, @flawr por ter encontrado o concorrente do Matlab aqui :)


Parece funcionar também com o Octave.
Dennis

4

JavaScript (ES6), 23 bytes

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

Com base na primeira fórmula na página OEIS. Se você não se importa que o código demore quase uma eternidade para terminar com uma entrada de 30, podemos reduzir um byte:

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

Aqui está uma versão não recursiva, usando um forloop em eval: (32 bytes)

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

As regras, como atualmente escritas, invalidam essa resposta, pois f(35)retornam 15. Além disso, alerta de bomba de garfo: eu tive que fechar o Chromium para parar f(30)(revisão original) de rodar. : P
Dennis

1
@ Dennis Espere, então, se eu não puder gerar nenhum valor errado, o que devo fazer com entradas maiores que 30?
ETHproductions

Não tenho certeza (e espero que a regra seja alterada ), mas algo assim f=x=>x?(y=f(x-(x<31)))^y*2:1funcionaria.
Dennis

@ Dennis Ah, recorrer infinitamente = sem saída. Vou consertar isso quando voltar ao meu computador. Espero que essa regra também seja alterada.
ETHproductions

A regra foi removida da pergunta.
Dennis

3

Matlab, 77 70 bytes

Esta função calcula a n-ésima linha do triângulo Pascal por convolução repetida com [1,1](também conhecida como expansão binomial ou multiplicação repetida com um binomial) e calcula o número a partir disso.

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

3

Ruby, 26 bytes

função anônima com iteração.

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

essa função recursiva é um byte mais curta, mas como precisa ser nomeada para poder se referir a si mesma, acaba um byte a mais.

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

3

Ruby, 25 bytes

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

Mais curto que as outras respostas aqui até agora. Ele constrói essa sequência:

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

Em seguida, ele define n=1(isso realmente acontece enquanto a string está sendo criada) e avalia a string acima, retornando o resultado.


Isso *n=1realmente salva tudom=1;"m^=2*"*n+?1
Martin Ender

Não, mas fazê-lo com apenas uma variável é muito vistosas :)
Lynn

3

Samau , 4 bytes

Agora, a Samau possui funções integradas para multiplicação e potência XOR.

▌3$ⁿ

Dump hexadecimal (a Samau usa a codificação CP737):

dd 33 24 fc

Explicação:

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

Isso pode ser reduzido para 3 bytes trocando os dois primeiros comandos e eliminando a troca?
quintopia 22/01

@quintopia Não. A Samau coloca automaticamente a entrada na pilha como uma sequência e lê um número da sequência. Se trocarmos os dois primeiros comandos, ele tentará ler um número 3, que não é uma string.
alephalpha

por que a samau não tenta avaliar a string quando possível?
quintopia 23/01


2

Pure Bash (sem utilitários externos), 37

Os números inteiros Bash são assinados em 64 bits, portanto, isso funciona para entradas de até 62, inclusive:

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

2

Python 2.7.6, 38 33 bytes

Agradeço ao Dennis por remover alguns bytes!

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

1
Bem-vindo à programação de quebra-cabeças e código de golfe! exec'x^=x*2;'*input()economiza alguns bytes sobre a forabordagem.
Dennis

Isso é melhor do que a minha entrada em Python, que vou deixar aqui para a posteridade:f=lambda n:f(n-1)^2*f(n-1)if n>0 else 1
Jack Brounstein 23/12/15

2

Pitão, 7 bytes

uxyGGQ1

Experimente online: Demonstração

Explicação:

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


2

MIPS, 28 bytes

Entrada $a0, saída $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 bytes

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

0b\:converte um número em um vetor booleano (ou seja, bitstring), o XOR é implementado como "diferente de", 2/:converte um bitstring de volta em um número, tratando-o como um polinômio a ser avaliado e, x f/ycom xum número inteiro, é faplicado yprimeiro e depois ao seu saídas sucessivasx tempos de .

Exemplo de execução:

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

1

Ruby, 31 26 bytes

EDITAR: Alterado para um idioma completamente diferente! Todas as sugestões de golfe são bem-vindas!

Este programa bit a bit XORs o elemento anterior da sequência com o dobro duas vezes, ie f(n) = f(n-1) ^ 2*f(n-1).

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

1

MATL , 15 bytes

Semelhante à resposta de @ flawr :

i:1w"TToX+]2\XB

EDIT (20 de maio de 2016) Experimente online! com X+substituídas por Y+se conformar com a versão 18.0.0 do idioma.

Exemplo

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

Explicação

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 bytes

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

Experimente online!

Assume células de tamanho infinito (caso contrário, não poderá ultrapassar 7, o que é convenientemente 255). O método do triângulo mod 2 de Pascal é realmente muito mais longo devido à operação cara do mod 2, enquanto o XOR é muito mais fácil de implementar.


0

APL, 31 bytes

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

Este é quase certamente um código terrível, mas eu sou um novato em APL completo. Espero que qualquer pessoa com alguma habilidade possa se livrar de todas as funções D e reduzi-la consideravelmente. A lógica é mais ou menos a mesma que a minha k4resposta - multiplique por 1ou 2, converta em bits com , XOR usando não iguais, converta novamente em um número com , envolva tudo em uma função e peça um número específico de iterações usando . Não faço ideia por que o resultado que sai do produto interno está incluído, mas o limpa.


Você deve conseguir salvar um byte alterando ~1 2=.para1 2≠.
Zacharý

E em qual sistema APL é esse? Se é em Dyalog, você deve ser capaz de fazê-lo {({2⊥⊃1 2≠.((64⍴2)⊤×)⍵}⍣⍵)1}[28 bytes]
Zachary

0

Sério, 12 bytes

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

Hex Dump:

322cb960324025604dee6aa8

Experimente online

Como Seriously não inclui nenhum meio de executar um xor bit a bit, essa solução aceita o desafio completamente literalmente, computando diretamente a linha do triângulo. Este método fornece respostas corretas até n = 1029 (após o que não há memória suficiente para calcular a linha do triângulo de Pascal).

Explicação:

 ,                       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 bytes

Đ0⇹Řć2%ǰ2Ĩ

Explicação:

Observando que o Triângulo Binário de Sierpinski é equivalente ao Triângulo de 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

Experimente online!


0

Stax , 5 bytes

±s┤ε─

Execute e depure online!

Resposta do porto da geléia.

Usa representação ASCII para explicar:

ODcH|^
O         Put 1 under top of stack
 D        Repeat for times specified by input
  cH|^    Xor the number with itself doubled
          Implicit output
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.