Die Drachenkurvenfolge (oder die reguläre Papierfaltfolge) ist eine binäre Folge. a(n)wird durch Negation des Bits links von der niedrigstwertigen 1 von gegeben n. Um zum Beispiel zu berechnen a(2136), konvertieren wir zuerst nach binär:

100001011000

Wir finden unser am wenigsten signifikantes Bit

100001011000
        ^

Nehmen Sie das Stück nach links

100001011000
       ^

Und erwidere seine Verneinung

0

Aufgabe

Bei einer positiven Ganzzahl als Eingabe wird ausgegeben a(n). (Sie können eine Ganzzahl oder einen Booleschen Wert ausgeben.) Sie sollten darauf abzielen, Ihren Code so klein wie möglich zu machen, gemessen in Bytes.

Testfälle

Hier sind die ersten 100 Einträge in Reihenfolge

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 Bytes

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

Andere Möglichkeiten, dies zu tun:

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,#]][[#]]&

Python 3 , 22 21 Bytes

1 Byte dank ETHproductions.

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

Probieren Sie es online!

Bitweise Arithmetik ftw.

Netzhaut ,38 34 29 Bytes

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

Probieren Sie es online!

Martin und Leaky hatten im Wesentlichen diese Idee, um 5 Bytes mehr zu sparen!

Wandelt die Eingabe in eine unäre um und dividiert die Zahl dann schrittweise durch 2. Wenn dies nicht mehr gleichmäßig möglich ist (dh die Zahl ist ungerade), werden Patches von 4 aus der Eingabe entfernt und das Ergebnis der letzten Operation Mod 4 berechnet Schließlich wird geprüft, ob das Ergebnis 1 war, was bedeutet, dass die Ziffer links vom niedrigstwertigen 1-Bit Null war. Wenn dies zutrifft, ist das Endergebnis 1, andernfalls ist es Null.

Gelee , 5 Bytes

&N&HṆ

Probieren Sie es online!

Wie es funktioniert

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

I2z1xnO@

Probieren Sie es online!

Übernimmt die Eingabe als Codepunkt eines Unicode-Zeichens und gibt das Ergebnis entsprechend als 0x00- oder 0x01-Byte aus.

Aus Gründen der Testbarkeit ist hier eine dezimale E / A-Version mit 12 Byte angegeben, die denselben Algorithmus verwendet (nur die E / A sind unterschiedlich):

/o
\i@/2z1xn

Probieren Sie es online!

Wenn Alice eine Golfsprache wäre und keine explizite Eingabe / 2z1xnAusgabe und Programmbeendigung erfordern würde, würde dies mit nur 5 Bytes ( ) eintakten, die sowohl 05AB1E als auch Jelly schlagen.

Erläuterung

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 Bytes

b0ܨθ≠

Probieren Sie es online!

Wise , 28 20 16 Bytes

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

Probieren Sie es online!

Erläuterung

Dies ist eine Portierung von Leaky Nuns Python-Antwort. TIO funktioniert leider nicht, da die Version des Interpreters von TIO etwas veraltet ist.

Wir beginnen damit, 3 Kopien unserer Eingabe mit zu ::erstellen, und dekrementieren dann die oberste Kopie um 1. Dadurch werden alle Bits bis zur ersten 1 hochgeklappt. Anschließend xor dies mit einer weiteren Kopie unserer Eingabe. Da alle Bits bis zur ersten 1 an unserem Eingang umgedreht wurden, haben alle diese Bits 1 im Ergebnis. Wenn wir dann eins ~-zum Ergebnis hinzufügen , erhalten wir eine einzelne 1 an der Stelle links von unserer niedrigstwertigen 1. Wir UND dies mit der Eingabe, um das Bit von der Eingabe zu erhalten. Jetzt haben wir 0iff das Bit war aus und eine Potenz von 2 iff das Bit war an, können wir dies in eine einzelne 1oder 0mit ändern :[?>]. Sobald dies erledigt ist, müssen wir nur das Bit negieren ~-^und wir sind fertig.

Python 2 , 19 Bytes

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

Probieren Sie es online!

Haskell , 45 43 39 Bytes

6 Bytes gespart dank nimi

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

Probieren Sie es online!

x86-Maschinencode, 17 16 15 Byte:

Es wird ein ABI angenommen, bei dem die Parameter auf den Stack übertragen werden und der Rückgabewert im ALRegister enthalten ist.

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

Dies wird wie folgt zerlegt:

_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 Bytes

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

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

Bearbeiten: 3 Bytes durch Portierung von @ Dennis Antwort gespeichert, als ich bemerkte, dass die boolesche Ausgabe akzeptabel war.

C (gcc) , 20 Bytes

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

Probieren Sie es online!

INTERCAL , 50 Bytes

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

INTERCALs unäre Operatoren sind dafür sehr gut geeignet, deshalb habe ich beschlossen, meinen ersten Beitrag zu schreiben.

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

Haskell , 33 Bytes

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

Probieren Sie es online!

Verwendet die 0-Indizierung.

Gelee , 7 6 Bytes

1 Byte danke an Erik den Outgolfer.

Bt0ṖṪṆ

Probieren Sie es online!

Längere Programme

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

,,, , 10 9 Bytes

::0-&2*&¬

Erläuterung

Nehmen Sie zum Beispiel die Eingabe 3.

::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 Bytes

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

Probieren Sie es online!

Boolesche Ausgabe.

Oktave , 34 Bytes

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

Probieren Sie es online!

Erläuterung:

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

Einreichung:

Python 2 , 41 39 Bytes

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

Probieren Sie es online!

-2 Bytes dank FryAmTheEggman

Anfangslösung:

Python 2 , 43 Bytes

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

Probieren Sie es online!

MATL , 11 10 Bytes

t4*YF1)Z.~

Probieren Sie es online! Oder sehen Sie sich die ersten 100 Ausgänge an .

Erläuterung

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 Bytes

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

Verwendung der Kronecker-Symbol .

Probieren Sie es online!

Befunge-98 , 19 Bytes

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

Probieren Sie es 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?) Zeichen, 99 (78?) Bytes

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

wo iist der eingang.

Wie Sie sehen, spare ich 21 Bytes, wenn ich mich nicht um die Null kümmere (wie es der Autor in seinem Testfall getan hat):

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

Dies ist mein erster Codegolf, also hoffe ich, dass ich es gut gemacht habe :)

Probieren Sie es online! Obwohl es ziemlich lang ist, lol zu berechnen.

C (gcc) , 35-31 Bytes

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

Zu einer rekursiven Implementierung gewechselt. Probieren Sie es online!

Java 8, 17 Bytes

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

Einfache Portierung der Python 3-Antwort von LeakyNun . Ich bin mit bitweisen Operationen und der Rangfolge von Operatoren nicht vertraut genug, um eine kürzere Lösung zu finden. Vielleicht gibt es eine Möglichkeit, die zusätzliche Elternschaft zu vermeiden?

Japt , 10 8 9 Bytes

!+¢g¢a1 É

Probieren Sie es online!

Erläuterung

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

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

PHP Sandbox Online

PHP , 40 Bytes

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

Probieren Sie es online!

PHP , 41 Bytes

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

Probieren Sie es online!

Common Lisp, 56 Bytes

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

Probieren Sie es online!

Chip , 93 Bytes

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

Nimmt die Eingabe als Little-Endian-Bytes. (Das TIO hat ein bisschen Python, das dies für Sie erledigt). Gibt entweder 0x0oder aus0x1 . (Der TIO prüft den Wert mit xxd).

Probieren Sie es online!

Wie geht das?

Der Chip betrachtet die Eingabe Byte für Byte. Bei der Verarbeitung von Multibyte-Eingaben wird ein gewisser Speicherplatz hinzugefügt, der jedoch nicht so groß ist, wie ich befürchtet hatte.

Lassen Sie uns darauf eingehen:

HZABCDEFG

Dies sind das HZHigh-Bit des vorherigen Bytes (falls vorhanden) und A- Gdie sieben unteren Bits des aktuellen Bytes. Diese werden verwendet, um das niedrigste gesetzte Bit der Zahl zu lokalisieren.

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

Wenn das niedrigste gesetzte Bit gefunden wird, haben wir ein paar Dinge zu tun. Dieser erste Block sagt: "Wenn wir ein gesetztes Bit (das )s) haben, Shören Sie auf, die Ausgabe zu tunterdrücken , und löschen Sie, nachdem wir die Antwort gedruckt haben.

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

Welchem ​​Bit des aktuellen Bytes ( A- H) nur ein Bündel von Nullen vorausgeht, dann eine Eins ( \und /: diese sehen die Bits direkt nördlich davon; wir können darauf vertrauen, dass alle vorherigen Bits Null waren), wird an die Drähte weitergeleitet das Recht ( v, ', ...), je nachdem , was dann Wert wird invertiert und als den Low - Bit des Ausgangs gegeben ( ~a).