Các chuỗi đường cong rồng (hoặc gấp dãy giấy thường xuyên) là một chuỗi nhị phân. a(n)được đưa ra bởi sự phủ định của bit còn lại của 1 ít quan trọng nhất n. Ví dụ để tính toán, a(2136)trước tiên chúng tôi chuyển đổi sang nhị phân:

100001011000

Chúng tôi tìm thấy bit ít quan trọng nhất của chúng tôi

100001011000
        ^

Lấy bit bên trái của nó

100001011000
       ^

Và trả lại phủ định của nó

0

Bài tập

Cho một số nguyên dương làm đầu vào, đầu ra a(n). (Bạn có thể xuất theo số nguyên hoặc boolean). Bạn nên đặt mục tiêu làm cho mã của bạn nhỏ nhất có thể được đo bằng byte.

Các trường hợp thử nghiệm

Dưới đây là 100 mục đầu tiên theo thứ tự

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

Toán học 25 byte

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

Những cách khác để làm điều này:

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 nhờ vào ETHproductions.

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

Hãy thử trực tuyến!

Số học bitw ftw.

Võng mạc ,38 34 29 byte

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

Hãy thử trực tuyến!

Martin và Leaky về cơ bản đã nảy ra ý tưởng này, để có thêm 5 byte!

Chuyển đổi đầu vào thành unary và sau đó chia dần số cho 2. Khi không thể làm điều đó một lần nữa (tức là số lẻ), sau đó xóa các bản vá 4 khỏi đầu vào, tính toán kết quả của mod hoạt động cuối cùng 4 Cuối cùng, điều này kiểm tra nếu kết quả là 1, có nghĩa là chữ số bên trái của 1 bit có ý nghĩa nhỏ nhất bằng không. Nếu đó là sự thật, kết quả cuối cùng là 1, nếu không thì bằng không.

Thạch , 5 byte

&N&HṆ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Hãy thử trực tuyến!

Lấy đầu vào là điểm mã của ký tự Unicode và xuất kết quả dưới dạng byte 0x00 hoặc 0x01 tương ứng.

Để kiểm tra, đây là phiên bản I / O thập phân ở mức 12 byte sử dụng cùng một thuật toán (chỉ I / O là khác nhau):

/o
\i@/2z1xn

Hãy thử trực tuyến!

Nếu Alice là ngôn ngữ chơi gôn và không yêu cầu I / O rõ ràng và chấm dứt chương trình, thì điều này sẽ chỉ ở mức 5 byte ( 2z1xn) đánh bại cả 05AB1E và Jelly.

Giải trình

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ܨθ≠

Hãy thử trực tuyến!

Khôn ngoan , 28 20 16 byte

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

Hãy thử trực tuyến!

Giải trình

Đây là một cổng của câu trả lời Python của Leaky Nun. Rất tiếc, nó không hoạt động trên TIO vì phiên bản trình thông dịch của TIO hơi lỗi thời.

Chúng tôi bắt đầu bằng cách tạo 3 bản sao đầu vào của chúng tôi ::, sau đó chúng tôi giảm số bản sao trên cùng xuống 1. Điều này sẽ lật tất cả các bit cho đến lần đầu tiên 1. Sau đó, chúng tôi xor cái này với một bản sao khác của đầu vào của chúng tôi. Vì tất cả các bit cho đến 1 đầu tiên trên đầu vào của chúng tôi đã được lật, điều này sẽ dẫn đến tất cả các bit đó là 1 trên kết quả. Sau đó, nếu chúng ta thêm một ~-vào kết quả, chúng ta sẽ nhận được 1 số duy nhất ở bên trái mức ít quan trọng nhất của chúng ta 1. Chúng ta VÀ cái này với đầu vào để lấy bit đó từ đầu vào. Bây giờ chúng ta sẽ có 0bit đó bị tắt và sức mạnh của 2 iff đó là bit, chúng ta có thể thay đổi nó thành một 1hoặc 0với :[?>]. Một khi điều này được thực hiện, chúng ta chỉ cần phủ định bit ~-^và chúng ta đã hoàn thành.

Python 2 , 19 byte

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

Hãy thử trực tuyến!

Haskell , 45 43 39 byte

6 byte được lưu nhờ nimi

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

Hãy thử trực tuyến!

Mã máy x86, 17 16 15 byte:

Giả sử ABI trong đó các tham số được đẩy trên ngăn xếp và giá trị trả về nằm trong thanh ALghi.

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

Điều này được tháo rời như sau:

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

Chỉnh sửa: Đã lưu 3 byte bằng cách chuyển câu trả lời của @ Dennis khi tôi nhận thấy rằng đầu ra boolean có thể chấp nhận được.

C (gcc) , 20 byte

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

Hãy thử trực tuyến!

INTERCAL , 50 byte

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

Các nhà khai thác unary INTERCALs khá phù hợp cho việc này, vì vậy tôi quyết định viết bài đầu tiên của mình.

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!!)

Hãy thử trực tuyến!

Sử dụng chỉ mục 0.

Thạch , 7 6 byte

1 byte nhờ Erik the Outgolfer.

Bt0ṖṪṆ

Hãy thử trực tuyến!

Chương trình dài hơn

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

,,, , 10 9 byte

::0-&2*&¬

Giải trình

Lấy đầu vào là 3 chẳng hạn.

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

Hãy thử trực tuyến!

Đầu ra Boolean.

Octave , 34 byte

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

Hãy thử trực tuyến!

Giải trình:

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

Nộp hồ sơ:

Python 2 , 41 39 byte

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

Hãy thử trực tuyến!

-2 byte nhờ FryAmTheEggman

Giải pháp ban đầu:

Python 2 , 43 byte

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

Hãy thử trực tuyến!

MATL , 11 10 byte

t4*YF1)Z.~

Hãy thử trực tuyến! Hoặc xem 100 đầu ra đầu tiên .

Giải trình

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

Sử dụng biểu tượng Kronecker .

Hãy thử trực tuyến!

Befunge-98 , 19 byte

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

Hãy thử trực tuyến!

&#                       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, ký tự 99 (78?), 99 (78?) Byte

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

nơi ilà đầu vào.

Như bạn có thể thấy, tôi sẽ lưu 21 byte nếu tôi không quan tâm đến số 0 (như tác giả đã làm trong trường hợp thử nghiệm của mình):

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

Đây là codegolf đầu tiên của tôi vì vậy tôi hy vọng tôi đã làm tốt :)

Hãy thử trực tuyến! Mặc dù nó khá dài để tính toán lol.

C (gcc) , 35 31 byte

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

Chuyển sang thực hiện đệ quy. Hãy thử trực tuyến!

Java 8, 17 byte

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

Cổng đơn giản của câu trả lời Python 3 của LeakyNun . Tôi không đủ quen thuộc với các hoạt động bitwise và ưu tiên toán tử để xem một giải pháp ngắn hơn; có lẽ có một cách để tránh cha mẹ thêm?

Japt , 10 8 9 byte

!+¢g¢a1 É

Hãy thử trực tuyến!

Giải trình

!+¢   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 trực tuyến

PHP , 40 byte

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

Hãy thử trực tuyến!

PHP , 41 byte

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

Hãy thử trực tuyến!

Lisp thông thường, 56 byte

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

Hãy thử trực tuyến!

Chip , 93 byte

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

Đưa đầu vào dưới dạng byte cuối nhỏ. (TIO có một chút trăn làm điều này cho bạn). Cung cấp đầu ra như một trong hai 0x0hoặc 0x1. (TIO sử dụng xxd để kiểm tra giá trị).

Hãy thử trực tuyến!

Làm thế nào để làm điều này?

Chip xem xét một byte đầu vào tại một thời điểm, do đó, việc xử lý đầu vào đa nhân thêm một số lượng lớn, nhưng không nhiều như tôi đã sợ.

Chúng ta hãy đi vào nó:

HZABCDEFG

Đây là HZ, bit cao của byte trước đó (nếu có một) và A- G, bảy bit thấp hơn của byte hiện tại. Chúng được sử dụng để xác định vị trí bit thiết lập thấp nhất của số.

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

Khi tìm thấy bit thiết lập thấp nhất, chúng ta có một vài việc phải làm. Đoạn đầu tiên này cho biết "nếu chúng ta có một bit được đặt (thì )), sau đó dừng Snhấn mạnh đầu ra và tlặp lại sau khi chúng ta in câu trả lời.

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

Bất kỳ bit nào của byte hiện tại ( A- H) chỉ được đi trước bởi một số 0 sau đó một bit ( \và /: chúng nhìn vào các bit trực tiếp về phía bắc của chúng; chúng ta có thể tin rằng tất cả các bit trước đó đều bằng 0) được truyền qua các dây trên bên phải ( v,, '...), sau đó giá trị nào được đảo ngược và được đưa ra dưới dạng bit đầu ra thấp ( ~a).