A sequência da curva do dragão


23

A sequência da curva do dragão (ou a sequência regular de dobragem de papel) é uma sequência binária. a(n)é dado pela negação do bit restante do 1 menos significativo n. Por exemplo, para calcular a(2136), primeiro convertemos para binário:

100001011000

Encontramos o nosso pouco menos significativo

100001011000
        ^

Leve o bit para a esquerda

100001011000
       ^

E devolver sua negação

0

Tarefa

Dado um número inteiro positivo como entrada, saída a(n). (Você pode imprimir por número inteiro ou por booleano). Você deve tentar tornar seu código o menor possível, medido por bytes.

Casos de teste

Aqui estão as primeiras 100 entradas em ordem

1 1 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 1


9
O bit menos significativo de 100001011000é a 0. Você quer dizer o menos significativo 1?
scatter

Respostas:


16

Mathematica 25 Bytes

1/2+JacobiSymbol[-1,#]/2&

Outras maneiras de fazer isso:

56 bytes

(v:=1-IntegerDigits[#,2,i][[1]];For[i=1,v>0,i++];i++;v)&

58 bytes

1-Nest[Join[#,{0},Reverse[1-#]]&,{0},Floor@Log[2,#]][[#]]&

3
Uau! Uma resposta do mathematica e não é construída apenas. Tenha um voto positivo!
KeyWeeUsr

2
A única coisa que poderia tornar essa resposta ainda melhor é uma explicação de por que e como ela funciona. : P
Martin Ender

2
@MartinEnder arxiv.org/pdf/1408.5770.pdf Veja a observação após o Exemplo 13.
alephalpha

7

Python 3 , 22 21 bytes

1 byte graças à ETHproductions.

lambda n:n&2*(n&-n)<1

Experimente online!

Ftw aritmético bit a bit.


2
"Você pode produzir por número inteiro ou por booleano", então acho que você não precisa do 0+(...)?
Martin Ender

A ordem das operações aqui está realmente me confundindo. Pode n&1ser colocado entre parênteses? Ou é 1+(n^~-n)<1isso que pode ser colocado entre parênteses? Ou é 1+(n^~-n)...
ETHproductions

oh deus o que. era isso que eu estava procurando: o legal!
HyperNeutrino

&tem a menor prioridade, por isso é1+(n^~-n)
Leaky Nun

Ah, encontrei a tabela de precedência. Agora tudo faz sentido: P
ETHproductions

6

Retina ,38. 34 29 bytes

\d+
$*
+`^(1+)\1$|1111
$1
^1$

Experimente online!

Martin e Leaky vieram com essa idéia, com mais 5 bytes de desconto!

Converte a entrada em unário e, em seguida, divide progressivamente o número por 2. Uma vez que não pode mais fazer isso uniformemente (ou seja, o número é ímpar), remove os patches de 4 da entrada, calculando o resultado da última operação mod 4 Finalmente, isso verifica se o resultado foi 1, o que significa que o dígito à esquerda do 1 bit menos significativo foi zero. Se isso for verdade, o resultado final é 1, caso contrário, é zero.


31 bytes (devo postar eu mesmo?) #
Leaky Nun

Eu encontrei uma maneira de evitar a conversão binária completa e, em vez disso, basta dividir os fatores de 2 e verificar a igualdade com 1 (mod 4): tio.run/##K0otycxL/…
Martin Ender

@MartinEnder essencialmente meu algoritmo ... com 2 bytes de desconto
Leaky Nun

@LeakyNun Oh sim, ambos são a mesma ideia. Grandes mentes e outras coisas ...;)
Martin Ender

Vou editar isso, mas se qualquer um de vocês quer publicá-la eu vou voltar, como eu provavelmente não teria pensado que eu;)
FryAmTheEggman

6

Geléia , 5 bytes

&N&HṆ

Experimente online!

Como funciona

&N&HṆ  Main link. Argument: n

 N     Negate; yield -n.
&      Bitwise AND; compute n&-n.
       This yields the highest power of 2 that divides n evenly.
   H   Halve; yield n/2.
  &    Bitwise AND; compute n&-n&n/2. This rounds n/2 down if n is odd.
    Ṇ  Take the logical NOT of the result.

4

Alice , 8 bytes

I2z1xnO@

Experimente online!

Recebe entrada como o ponto de código de um caractere Unicode e gera o resultado como um byte 0x00 ou 0x01 em conformidade.

Para teste, aqui está uma versão de E / S decimal em 12 bytes que usa exatamente o mesmo algoritmo (apenas E / S é diferente):

/o
\i@/2z1xn

Experimente online!

Se Alice fosse uma linguagem de golfe e não exigisse E / S explícita e encerramento do programa, isso ocorreria a meros 5 bytes ( 2z1xn), superando 05AB1E e Jelly.

Explicação

I    Read input.
2z   Drop all factors of 2 from the input, i.e. divide it by 2 as long
     as its even. This shifts the binary representation to the right
     until there are no more trailing zeros.
1x   Extract the second-least significant bit.
n    Negate it.
O    Output it.
@    Terminate the program.


3

Sábio , 28 20 16 bytes

::-~^~-&:[?>]~-^

Experimente online!

Explicação

Esta é uma porta da resposta Python do Leaky Nun. Infelizmente, ele não funciona no TIO porque a versão do intérprete está um pouco desatualizada.

Começamos fazendo 3 cópias de nossa entrada com ::, em seguida, diminuímos a cópia superior em 1. Isso aumentará todos os bits até o primeiro 1. Em seguida, fazemos isso com outra cópia de nossa entrada. Como todos os bits até o primeiro 1 em nossa entrada foram invertidos, isso resultará em todos esses bits sendo 1 no resultado. Se adicionarmos um ~-ao resultado, obteremos um único 1 no local à esquerda do nosso 1. menos significativo. Nós AND com esta entrada para obter esse bit da entrada. Agora teremos 0se esse bit estiver desativado e uma potência de 2 se esse bit estiver ativado, podemos mudar isso para um único 1ou 0com :[?>]. Uma vez feito isso, precisamos apenas negar a parte ~-^e estamos prontos.



3

Haskell , 45 43 39 bytes

6 bytes salvos graças a nimi

f x|d<-div x 2=[f d,mod(1+d)2]!!mod x 2

Experimente online!


Você pode usar em divvez de quot.
N

Ainda melhor: divMod:f x|(d,m)<-divMod x 2=[mod(1+d)2,f d]!!m
nimi

@nimi Eu nem entendo como isso funciona. Você provavelmente deveria postar você mesmo.
Assistente de trigo

Ainda é o mesmo algoritmo, mas apenas uma forma diferente de escolher o ramo (recursivamente chamar f novamente vs. caso base), então sinta-se livre para editá-lo no. |(d,m)<-divMod x 2É um padrão de guarda para ligar dpara div x 2e mpara mod x 2. Usamos mpara indexar a lista de dois elementos [...,...]!!m. No caso de m==0retornarmos mod(1+d)2e no caso de m==1 f d.
nimi

1
Oh, desculpe, você tem que virar os elementos da lista: [f d,mod(1+d)2]. Experimente online! .
nimi

3

Código da máquina x86, 17 16 15 bytes:

Assume uma ABI em que os parâmetros são pressionados na pilha e o valor de retorno está no ALregistro.

8B 44 24 04 0F BC C8 41 0F BB C8 0F 93 C0 C3

Isso é desmontado da seguinte maneira:

_dragoncurve:
  00000000: 8B 44 24 04        mov         eax,dword ptr [esp+4]
  00000004: 0F BC C8           bsf         ecx,eax
  00000007: 41                 inc         ecx
  00000008: 0F BB C8           btc         eax,ecx
  0000000B: 0F 93 C0           setae       al
  0000000E: C3                 ret

1
@PeterTaylor Estou contando o tamanho da instrução CPU em bytes para a minha resposta; Essa é uma prática bastante comum no PPCG para respostas de montagem.
Govind Parmar

1
Eu não poderia dizer como é comum, mas é definitivamente errado
Peter Taylor

1
Não é apenas pedante, também é sem sentido. Não há distinção entre "código de máquina" e "código de montagem" no que diz respeito ao computador. A diferença é apenas uma interpretação. Atribuímos mnemônicos a bytes de código de máquina para facilitar a leitura por humanos. Em outras palavras, desmontamos os bytes para facilitar a compreensão.
Cody Grey

3
Isso é irrelevante, @ Peter. O código de montagem é apenas uma tradução legível por humanos do código de máquina. Eles são exatamente a mesma linguagem, apenas em duas formas / representações diferentes. Não é diferente do TI BASIC, onde é comum aceitar que contemos tokens , em vez de bytes de caracteres, porque é assim que o sistema os armazena internamente. O mesmo se aplica à linguagem assembly: os mnemônicos de instruções não são armazenados como caracteres individuais, mas representados como bytes de código de máquina equivalente.
Cody Grey

2
Além disso, em termos práticos, porque é que ninguém nunca entram expandiu mnemônicos montagem de língua em uma competição de código-golf, quando poderiam traduzi-los em código de máquina equivalente a 100%, onde a entrada é garantida para ser mais curto de graça? Isso por si só faz uma distinção entre os dois sem sentido, se não totalmente absurdo.
Cody Grey

3

JavaScript (ES6), 17 14 bytes

f=
n=>!(n&-n&n/2)
<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Edit: Salvo 3 bytes, portando a resposta de @ Dennis, uma vez que notei que a saída booleana era aceitável.


3

C (gcc) , 20 bytes

f(n){n=!(n&-n&n/2);}

Experimente online!


Na verdade, isso não "funciona"; você está contando com uma peculiaridade do gerador de código para uma versão específica do compilador direcionada a uma arquitetura específica, em que cálculos intermediários são feitos no mesmo registro usado para valores de retorno. A ativação de qualquer tipo de otimização, a alteração da arquitetura de destino ou o uso de uma versão diferente do GCC interromperão isso. Você também pode dizer "o lixo na minha pilha contém a saída correta quando há lua cheia em 13 de outubro".
Cody Grey

Embora tudo o que você diga seja verdadeiro e um código como esse nunca seja usado no código de produção, definimos os idiomas por suas implementações para os propósitos do código golf. Sem sinalizadores adicionais, isso funciona em todas as versões recentes do gcc e do tcc e só precisa funcionar em uma versão para ser considerado válido.
Dennis

"definimos linguagens por suas implementações para fins de código golf" Espere, o que? Então, todo sinalizador de compilador e toda versão do GCC define um idioma diferente? Você percebe que isso é loucura, certo? O padrão da linguagem C é o que define a linguagem.
Cody Grey

Aqui não. Se houvesse um padrão C, mas nenhuma implementação, nem o consideraríamos uma linguagem. Como eu disse antes, o compilador define o idioma . Como resultado, é permitido confiar em um comportamento indefinido . Um conjunto diferente de sinalizadores não é considerado um idioma diferente, mas, a menos que você os adicione à sua contagem de bytes, todas as respostas usam sinalizadores de compilação padrão.
Dennis

Uau. Isso é loucura. Quer dizer, eu poderia entender se você estava dizendo que definido pela implementação comportamento é permitido, mas um comportamento indefinido é não definido pela implementação. É literalmente indefinido. A implementação pode fazer coisas aleatórias a cada vez. E essa noção de "sinalizadores de compilação padrão" é algo que você acabou de inventar. Meus sinalizadores de compilação padrão incluem vários que quebram seu código. E eu dificilmente acho que o otimizador não seja padrão. Bem, claramente este site não é para mim.
Cody Grey

3

INTERCAL , 50 bytes

DOWRITEIN.1DO.1<-!?1~.1'~#1DOREADOUT.1PLEASEGIVEUP

Os operadores unários da INTERCALs são bastante adequados para isso, então decidi escrever meu primeiro post.

DO WRITE IN .1
DO .1 <- !?1~.1'~#1
DO READ OUT .1
PLEASE GIVE UP



2

,,, , 10 9 bytes

::0-&2*&¬

Explicação

Tome a entrada como 3, por exemplo.

::0-&2*&1≥
               implicitly push command line argument       [3]
::             duplicate twice                             [3, 3, 3]
  0            push 0 on to the stack                      [3, 3, 3, 0]
   -           pop 0 and 3 and push 0 - 3                  [3, 3, -3]
    &          pop -3 and 3 and push -3 & 3 (bitwise AND)  [3, 1]
     2         push 2 on to the stack                      [3, 1, 2]
      *        pop 2 and 1 and push 2 * 1                  [3, 2]
       &       pop 2 and 3 and push 2 & 3                  [2]
        ¬      pop 2 and push ¬ 2 (logical NOT)            [0]
               implicit output                             []


2

Oitava , 34 bytes

@(x)~(k=[de2bi(x),0])(find(k,1)+1)

Experimente online!

Explicação:

@(x)                               % Anonymous function taking a decimal number as input
    ~....                          % Negate whatever comes next
     (   de2bi(x)   )              % Convert x to a binary array that's conveniently 
                                   % ordered with the least significant bits first
        [de2bi(x),0]               % Append a zero to the end, to avoid out of bound index
     (k=[de2bi(x),0])              % Store the vector as a variable 'k'
                     (find(k,1)    % Find the first '1' in k (the least significant 1-bit)
                               +1  % Add 1 to the index to get the next bit
     (k=[de2bi(x),0])(find(k,1)+1) % Use as index to the vector k to get the correct bit

Como é que eu nunca ouvi falar de de2bi ...: O
Sanchises

1

Submissão:

Python 2 , 41 39 bytes

x=input()
while~-x&1:x/=2
print 1-x/2%2

Experimente online!

-2 bytes graças a FryAmTheEggman

Solução inicial:

Python 2 , 43 bytes

lambda x:1-int(bin(x)[bin(x).rfind('1')-1])

Experimente online!


Então, qual é a sua submissão?
Leaky Nun

@LeakyNun O primeiro porque é mais curto; o segundo foi o meu envio original. Devo publicá-las separadamente?
HyperNeutrino

~-x&1funciona para a condição while, eu acho.
FryAmTheEggman

(Eu esqueço o nome de usuário); Rejeitei sua edição porque edições no golfe do código de outras pessoas não são recomendadas no PPCG. Você pode postar sugestões (btw, obrigado @FryAmTheEggman), mas não faça edições no golfe. Obrigado!
HyperNeutrino

@ StewieGriffin Ah sim, obrigado. Infelizmente, não consigo executar ping no usuário porque a edição foi rejeitada.
HyperNeutrino

1

MATL , 11 10 bytes

t4*YF1)Z.~

Experimente online! Ou veja as 100 primeiras saídas .

Explicação

t    % Implicit input. Duplicate
4*   % Multiply by 4. This ensures that the input is a multiple of 2, and
     % takes into account that bit positions are 1 based
YF   % Exponents of prime factorization
1)   % Get first exponent, which is that of factor 2
Z.   % Get bit of input at that (1-based) position
~    % Negate. Implicit display


1

Befunge-98 , 19 bytes

&#;:2%\2/\#;_;@.!%2

Experimente online!

&#                       Initial input: Read a number an skip the next command
  ;:2%\2/\#;_;           Main loop: (Direction: East)
   :2%                    Duplicate the current number and read the last bit
      \2/                 Swap the first two items on stack (last bit and number)
                          and divide the number by two => remove last bit
         \                swap last bit and number again
          #;_;            If the last bit is 0, keep going East and jump to the beginning of the loop
                          If the last bit is 1, turn West and jump to the beginning of the loop, but in a different direction.
&#;           @.!%2      End: (Direction: West)
&#                        Jump over the input, wrap around
                 %2       Take the number mod 2 => read the last bit
               .!         Negate the bit and print as a number
              @          Terminate

1

SCALA, 99 (78?) Caracteres, 99 (78?) Bytes

if(i==0)print(1)else
print(if(('0'+i.toBinaryString).reverse.dropWhile(x=>x=='0')(1)=='1')0 else 1)

Onde iestá a entrada.

Como você pode ver, economizo 21 bytes se não cuidar do zero (como o autor fez no caso de teste):

print(if(('0'+i.toBinaryString).reverse.dropWhile(x=>x=='0')(1)=='1')0 else 1)

Este é o meu primeiro codegolf, então espero ter me saído bem :)

Experimente online! Embora seja muito longo para calcular lol.


Bem vindo ao site!
DJMcMayhem


1

Java 8, 17 bytes

n->(n&2*(n&-n))<1

Porta direta da resposta Python 3 do LeakyNun . Não estou familiarizado o suficiente com operações bit a bit e precedência de operadores para ver uma solução mais curta; talvez haja uma maneira de evitar a parêntese extra?


0

Japonês , 10 8 9 bytes

!+¢g¢a1 É

Experimente online!

Explicação

!+¢   g    a1 É
!+Us2 gUs2 a1 -1 # Implicit input (U) as number
!+               # Return the boolean NOT of
      g          #   the character at index
       Us2       #     the input converted to binary
           a1    #     the index of its last 1
              -1 #     minus 1
      g          #   in string
  Us2            #     the input converted to binary

Isso retorna falsepara tudo, porque o caractere (0 ou 1) é sempre uma string.
Shaggy

Opa, deveria ter notado que ... resolvido agora
Lucas

Parece que falhou por1 enquanto.
Shaggy

0

JavaScript (ES6), 53 34 bytes

a=>eval("for(;~a&1;a/=2);~a>>1&1")

42 bytes:a=>!+(a=a.toString(2))[a.lastIndexOf(1)-1]
Shaggy

Eu já encontrei uma solução mais curta (matemática) ...
Lucas

Bom :) Se importa se eu postar esse 42 bytes?
Shaggy

@Shaggy, nenhum não em todos
Lucas



0

Chip , 93 bytes

HZABCDEFG,t
 ))))))))^~S
H\\\\\\\/v~a
G\\\\\\/v'
F\\\\\/v'
E\\\\/v'
D\\\/v'
C\\/v'
B\/v'
A/-'

Recebe entrada como pequenos bytes endian. (O TIO possui um pouco de python que faz isso por você). Dá saída como 0x0ou0x1 . (O TIO usa xxd para inspecionar o valor).

Experimente online!

Como faz isso?

O chip analisa a entrada um byte de cada vez, portanto, o manuseio da entrada multibyte adiciona um pouco de volume, mas não tanto quanto eu temia.

Vamos entrar nisso:

HZABCDEFG

Estes são HZ, bits altos do byte anterior (se houver um) e A- G, os sete bits inferiores do byte atual. Eles são usados ​​para localizar o bit mais baixo definido do número.

        ,t
))))))))^~S

Quando o bit mais baixo é encontrado, temos algumas coisas a fazer. Esse primeiro pedaço diz "se tivermos um bit definido ( )s), então pare de Spressionar a saída e ttermine depois de imprimir a resposta.

H\\\\\\\/v~a
G\\\\\\/v'
...
A/-'

Qualquer bit do byte atual ( A- H) é precedido apenas por um monte de zeros e, em seguida, um ( \e /: estes olham para os bits diretamente ao norte deles; podemos confiar que todos os bits anteriores eram zero) são passados ​​para os fios nos a direita ( v, '...), então qualquer que seja o valor que ele está é invertido e dado como o baixo pouco de saída ( ~a).

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.