所述龙曲线序列（或常规纸张折叠序列）是一个二进制序列。 a(n)通过对的最低有效1的左位求反得到n。例如要进行计算，a(2136)我们首先将其转换为二进制：

100001011000

我们发现我们的最低有效位

100001011000
        ^

左移一点

100001011000
       ^

并返回其否定

0

任务

给定一个正整数作为输入，输出a(n)。（您可以按整数或布尔值输出）。您应该努力使代码尽可能地小（以字节为单位）。

测试用例

这是顺序的前100个条目

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字节

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

其他执行此操作的方法：

56个字节

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

58个字节

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

Python 3中，22 21个字节

1个字节，感谢ETHproductions。

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

在线尝试！

按位运算ftw。

视网膜，38 34 29个字节

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

在线尝试！

Martin和Leaky本质上提出了这个想法，又减少了5个字节！

将输入转换为一元，然后将数字逐步除以2。一旦无法再均匀地处理数字（即数字为奇数），则从输入中删除4的补丁，计算最后一次操作mod 4的结果最后，这将检查结果是否为1，这意味着最低有效1位左侧的数字为零。如果为真，则最终结果为1，否则为零。

果冻，5个字节

&N&HṆ

在线尝试！

怎么运行的

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

爱丽丝，8字节

I2z1xnO@

在线尝试！

将输入作为Unicode字符的代码点，并相应地将结果输出为0x00或0x01字节。

为了进行测试，以下是12字节的十进制I / O版本，它使用完全相同的算法（只有I / O不同）：

/o
\i@/2z1xn

在线尝试！

如果Alice是一种高尔夫语言，并且不需要显式的I / O和程序终止，那么它将仅以5个字节（2z1xn）的速度跳动05AB1E和Jelly。

说明

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个字节

b0ܨθ≠

在线尝试！

明智，28 20 16字节

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

在线尝试！

说明

这是Leaky Nun的Python回答的一部分。不幸的是，它不适用于TIO，因为TIO的解释器版本有些过时。

我们首先使用制作3个输入副本::，然后将最上面的副本减1。这会将所有位向上翻转直到第一个1。然后将其与输入的另一个副本进行异或。由于直到我们输入的第一个1之前的所有位都被翻转，这将导致结果中所有这些位均为1。如果再将~-结果加1 ，则在最低有效位1 左侧的位置将得到一个1。将其与输入进行“与”运算以从输入中获得该位。现在，0如果该位已关闭，并且有2的幂（该位已打开），我们可以将其更改为single 1或0with :[?>]。完成此操作后，我们只需要取反该位~-^就可以完成。

Python 2，19个字节

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

在线尝试！

Haskell，45 43 39字节

多亏了nimi，节省了6个字节

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

在线尝试！

x86机器代码，17 16 15字节：

假定一个ABI，其中参数被压入堆栈，并且返回值在AL寄存器中。

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

分解如下：

_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字节

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

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

编辑：我注意到布尔输出是可以接受的，通过移植@Dennis的答案节省了3个字节。

C（gcc），20个字节

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

在线尝试！

INTERCAL，50个字节

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

INTERCAL的一元运算符非常适合此操作，因此我决定写我的第一篇文章。

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

Haskell，33个字节

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

在线尝试！

使用0索引。

果冻，7 6字节

1个字节，感谢Outgolfer的Erik。

Bt0ṖṪṆ

在线尝试！

更长的程序

• 7个字节： Họ¡2&2Ị
• 7个字节： Bt0ṫ-ḄỊ

,,,，10 9 个字节

::0-&2*&¬

说明

以输入为例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个字节

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

在线尝试！

布尔输出。

八度，34字节

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

在线尝试！

说明：

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

提交内容：

Python 2中，41 39个字节

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

在线尝试！

-2字节归功于FryAmTheEggman

初始解决方案：

Python 2，43个字节

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

在线尝试！

MATL，11个10字节

t4*YF1)Z.~

在线尝试！或查看前100个输出。

说明

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字节

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

使用Kronecker符号。

在线尝试！

Befunge-98，19个字节

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

在线尝试！

&#                       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？）个字符，99（78？）个字节

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

i输入在哪里。

如您所见，如果我不注意零，我确实会节省21个字节（就像作者在他的测试用例中所做的那样）：

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

这是我的第一个代码高尔夫球，所以我希望我做得很好:)

在线尝试！尽管计算哈哈很长。

C（gcc），35 31字节

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

切换到递归实现。 在线尝试！

Java 8，17字节

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

简单易用的LeakyNun的Python 3答案端口。我对按位运算和运算符优先级还不太熟悉，因此无法找到更短的解决方案。也许有一种方法可以避免多余的括号？

Japt，10 8 9字节

!+¢g¢a1 É

在线尝试！

说明

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

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

PHP> = 7.1，32字节

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

PHP沙盒在线

PHP，40字节

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

在线尝试！

PHP，41字节

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

在线尝试！

通用Lisp，56个字节

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

在线尝试！

芯片，93字节

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

将输入作为小字节序字节。（TIO有一些python可以为您完成此操作）。输出为0x0或0x1。（TIO使用xxd检查该值）。

在线尝试！

这个怎么样

芯片一次只看输入一个字节，因此处理多字节输入会增加一些体积，但不如我所担心的那么大。

让我们开始吧：

HZABCDEFG

这些是HZ，前一个字节的高位（如果有的话），以及A-G，当前字节的低七位。这些用于查找数字的最低设置位。

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

找到最低设置位后，我们有几件事要做。第一个块说：“如果我们有一个固定的位)，则停止S升压输出，然后t在打印答案后终止。

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

当前字节（A- H）的任何一位仅以一串零开头，然后是一个（\和/：（这些字符直接看它们以北的位；我们可以相信所有以前的位均为零））传递到导线上向右（v，，'...），则取其取反的任何值，并指定为输出（~a）的低位。