La sequenza della curva del drago (o la normale sequenza di piegatura della carta) è una sequenza binaria. a(n)è dato dalla negazione del bit rimasto del 1 meno significativo di n. Ad esempio per calcolare a(2136), convertiamo prima in binario:

100001011000

Troviamo il nostro bit meno significativo

100001011000
        ^

Prendi il bit alla sua sinistra

100001011000
       ^

E restituisce la sua negazione

0

Compito

Dato un numero intero positivo come input, output a(n). (È possibile generare un numero intero o un valore booleano). Dovresti mirare a rendere il tuo codice il più piccolo possibile, misurato in byte.

Casi test

Ecco le prime 100 voci in ordine

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

Mathematica 25 byte

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

Altri modi per farlo:

56 byte

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

58 byte

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

Python 3 , 22 21 byte

1 byte grazie a ETHproductions.

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

Provalo online!

Ftw aritmetico bit a bit.

Retina ,38 34 29 byte

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

Provalo online!

In sostanza Martin e Leaky hanno avuto questa idea, per altri 5 byte di sconto!

Converte l'input in unario, quindi divide progressivamente il numero per 2. Una volta che non può più farlo in modo uniforme (ovvero il numero è dispari), rimuove le patch di 4 dall'input, calcolando il risultato dell'ultima operazione mod 4 Infine, questo controlla se il risultato è 1, il che significa che la cifra a sinistra del 1 bit meno significativo era zero. Se questo è vero, il risultato finale è 1, altrimenti è zero.

Gelatina , 5 byte

&N&HṆ

Provalo online!

Come funziona

&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.

Alice , 8 byte

I2z1xnO@

Provalo online!

Accetta l'input come punto di codice di un carattere Unicode e genera il risultato come byte 0x00 o 0x01 di conseguenza.

Per verificabilità, ecco una versione I / O decimale a 12 byte che utilizza esattamente lo stesso algoritmo (solo I / O è diverso):

/o
\i@/2z1xn

Provalo online!

Se Alice fosse un linguaggio da golf e non richiedesse l'I / O esplicito e la terminazione del programma, questo avrebbe un clock di soli 5 byte ( 2z1xn) battendo sia 05AB1E che Jelly.

Spiegazione

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.

05AB1E , 6 byte

b0ܨθ≠

Provalo online!

Saggio , 28 20 16 byte

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

Provalo online!

Spiegazione

Questa è una porta della risposta Python di Leaky Nun. Sfortunatamente non funziona su TIO perché la versione dell'interprete di TIO è un po 'datata.

Iniziamo facendo 3 copie del nostro input con ::, quindi diminuiamo la copia in alto di 1. In questo modo capovolgeremo tutti i bit fino al primo 1. Dopodiché xoreremo questo con un'altra copia del nostro input. Dal momento che tutti i bit fino al primo 1 sul nostro input sono stati invertiti, ciò comporterà che tutti quei bit saranno 1 sul risultato. Se poi ne aggiungiamo uno ~-al risultato, otterremo un singolo 1 nel punto a sinistra del nostro meno significativo 1. Noi AND questo con l'input per ottenere quel bit dall'input. Ora avremo 0iff quel bit era spento e una potenza di 2 iff quel bit era acceso, possiamo cambiarlo in uno singolo 1o 0con :[?>]. Una volta fatto ciò, dobbiamo solo negare il bit ~-^e abbiamo finito.

Python 2 , 19 byte

lambda n:n&-n&n/2<1

Provalo online!

Haskell , 45 anni 43 39 byte

6 byte salvati grazie a nimi

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

Provalo online!

Codice macchina x86, 17 16 15 byte:

Presuppone un ABI in cui i parametri vengono inseriti nello stack e il valore restituito si trova nel ALregistro.

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

Questo è smontato come segue:

_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

JavaScript (ES6), 17 14 byte

f=
n=>!(n&-n&n/2)

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Modifica: salvato 3 byte eseguendo il porting della risposta di Dennis una volta che ho notato che l'output booleano era accettabile.

C (gcc) , 20 byte

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

Provalo online!

INTERCAL , 50 byte

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

Gli operatori unari di INTERCAL sono abbastanza adatti per questo, quindi ho deciso di scrivere il mio primo post.

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

Haskell , 33 byte

g~(a:b:c)=1:a:0:b:g c
d=g d
(d!!)

Provalo online!

Utilizza l'indicizzazione 0.

Gelatina , 7 6 byte

1 byte grazie a Erik the Outgolfer.

Bt0ṖṪṆ

Provalo online!

Programmi più lunghi

• 7 byte: Họ¡2&2Ị
• 7 byte: Bt0ṫ-ḄỊ

,,, , 10 9 byte

::0-&2*&¬

Spiegazione

Prendi input come 3 per esempio.

::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                             []

Haskell , 26 byte

f n=even$div n$2*gcd(2^n)n

Provalo online!

Uscita booleana.

Ottava , 34 byte

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

Provalo online!

Spiegazione:

@(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

Presentazione:

Python 2 , 41 39 byte

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

Provalo online!

-2 byte grazie a FryAmTheEggman

Soluzione iniziale:

Python 2 , 43 byte

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

Provalo online!

MATL , 11 10 byte

t4*YF1)Z.~

Provalo online! Oppure vedi le prime 100 uscite .

Spiegazione

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

Pari / GP , 20 byte

n->kronecker(-1,n)>0

Usando il simbolo Kronecker .

Provalo online!

Befunge-98 , 19 byte

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

Provalo 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

SCALA, 99 (78?) Caratteri, 99 (78?) Byte

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

dov'è il'input.

Come puoi vedere, salvo 21 byte se non mi occupo dello zero (come ha fatto l'autore nel suo caso di test):

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

Questo è il mio primo codegolf quindi spero di aver fatto bene :)

Provalo online! Anche se è abbastanza lungo calcolare lol.

C (gcc) , 35 31 byte

f(x){return~x&1?f(x/2):!(x&2);}

Passato a un'implementazione ricorsiva. Provalo online!

Java 8, 17 byte

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

Porta semplice della risposta Python 3 di LeakyNun . Non ho abbastanza familiarità con le operazioni bit per bit e la precedenza dell'operatore per vedere una soluzione più breve; forse c'è un modo per evitare l'ulteriore parenteesi?

Japt , 10 8 9 byte

!+¢g¢a1 É

Provalo online!

Spiegazione

!+¢   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

JavaScript (ES6), 53 34 byte

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

PHP> = 7.1, 32 byte

<?=1^!trim(decbin($argn),0)[-2];

PHP Sandbox online

PHP , 40 byte

for($i=$argn;$i%2<1;)$i/=2;echo$i/2%2^1;

Provalo online!

PHP , 41 byte

<?=1^preg_match("#110*$#",decbin($argn));

Provalo online!

Lisp comune, 56 byte

(defun f(n)(if(oddp n)(- 1(mod #1=(ash n -1)2))(f #1#)))

Provalo online!

Chip , 93 byte

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

Accetta input come piccoli byte endian. (Il TIO ha un po 'di pitone che lo fa per te). Fornisce output come 0x0o 0x1. (Il TIO usa xxd per ispezionare il valore).

Provalo online!

Come si fa?

Il chip esamina l'input di un byte alla volta, quindi la gestione dell'ingresso multibyte aggiunge un po 'di volume, ma non così vicino come avevo temuto.

Andiamo dentro:

HZABCDEFG

Questi sono HZ, bit alto del byte precedente (se ce n'era uno), e A- G, i sette bit inferiori del byte corrente. Questi vengono utilizzati per individuare il bit impostato più basso del numero.

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

Quando viene trovato il bit impostato più basso, abbiamo alcune cose da fare. Questo primo pezzo dice "se abbiamo un bit impostato ( )i), quindi smettiamo di Ssopprimere l'output ed teliminiamo dopo aver stampato la risposta.

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

Qualunque bit del byte corrente ( A- H) è preceduto solo da un gruppo di zero, quindi uno ( \e /: questi guardano i bit direttamente a nord di loro; possiamo fidarci che tutti i bit precedenti erano zero) viene passato ai fili su destra ( v, ', ...), poi scegliendo il valore è dato viene invertita ed il bit basso dell'uscita ( ~a).