Dragon eğri dizisi (veya normal kağıt katlama dizisi), bir ikili dizisidir. a(n)En az kayda değer olan 1'in bıraktığı bitin ihmali ile verilir n. Mesela hesaplamak a(2136)için önce binary'e dönüştürelim:

100001011000

En az anlamlı parçamızı bulduk

100001011000
        ^

Biraz soluna git

100001011000
       ^

Ve olumsuzluğunu iade et

0

Görev

Girdi olarak çıktı olarak pozitif bir tamsayı verilir a(n). (Tamsayı veya boolean tarafından çıktı alabilirsiniz). Kodunuzu bayt ile ölçüldüğü kadar küçük kılmayı amaçlamalısınız.

Test Kılıfları

İşte ilk 100 giriş

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 Bayt

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

Bunu yapmanın diğer yolları:

56 bayt

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

58 bayt

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

Python 3 , 22 21 bayt

ETHproductions ile 1 bayt.

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

Çevrimiçi deneyin!

Bitsel aritmetik ftw.

retina ,38 34 29 bayt

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

Çevrimiçi deneyin!

Martin ve Leaky bu fikirle ortaya çıktı, 5 bayt daha!

Girdiyi unary'e dönüştürür ve ardından aşamalı olarak 2'ye bölünür. Bunu artık eşit şekilde yapamadığı zaman (yani sayı tuhaf) sonra son işlem modunun sonucunu hesaplayarak girişten 4 yamasını kaldırır. Son olarak, bu, sonucun 1 olup olmadığını kontrol eder; bu, en az anlamlı 1 bitin solundaki rakamın sıfır olduğu anlamına gelir. Bu doğruysa, nihai sonuç 1 olur, aksi takdirde sıfırdır.

Jöle , 5 bayt

&N&HṆ

Çevrimiçi deneyin!

Nasıl çalışır

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

I2z1xnO@

Çevrimiçi deneyin!

Unicode karakterinin kod noktası olarak girdi alır ve sonucu buna göre 0x00 veya 0x01 bayt olarak verir.

Test edilebilirlik için, tam olarak aynı algoritmayı kullanan 12 baytlık bir ondalık giriş / çıkış versiyonu (sadece giriş / çıkış farklı):

/o
\i@/2z1xn

Çevrimiçi deneyin!

Eğer Alice bir golf 2z1xndiliydi ve açık G / Ç ve program sonlandırması gerektirmiyorsa, bu hem 05AB1E hem de Jelly'i yenen sadece 5 byte ( ) olacaktır.

açıklama

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 bayt

b0ܨθ≠

Çevrimiçi deneyin!

Bilge , 28 20 16 bayt

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

Çevrimiçi deneyin!

açıklama

Bu, Sızdıran Rahibe'nin Python cevabının limanı. Ne yazık ki TIO'da çalışmıyor çünkü TIO'nun tercüman sürümü biraz modası geçmiş.

Girdiimizin 3 kopyasını ile başlayarak başlıyoruz ::, sonra üst kopyayı 1'e düşürüyoruz. Bu, tüm bitleri ilk 1'e kadar çevirir. Sonra bunu girdilerimizin başka bir kopyasıyla gideriz. Girdideki ilk 1'e kadar olan bitlerin tümü çevrildiğinden, bu, sonuçta tüm bitlerin sonuçlanmasına neden olacaktır. Sonucuna bir tane eklersek , en az 1 değerimizin solundaki~- yerde tek bir 1 alırız. Şimdi o bitin kapalı olduğunu ve o bitin açık olduğunu 2'nin gücüne sahip olacağımızı, bunu bir tekli veya beraberinde değiştirebiliriz . Bu yapıldıktan sonra sadece biti yok etmeye ihtiyacımız var ve bitti.010:[?>]~-^

Python 2 , 19 bayt

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

Çevrimiçi deneyin!

Haskell , 45 43 39 bayt

Nimi sayesinde 6 bayt kaydedildi

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

Çevrimiçi deneyin!

x86 Makine Kodu, 17 16 15 bayt:

Parametrelerin yığına itildiği ve dönüş değerinin ALkayıt defterinde olduğu bir ABI varsayar .

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

Bu şu şekilde demonte edilir:

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

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

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

Düzenleme: Boolean çıktısının kabul edilebilir olduğunu fark ettikten sonra @ Dennis'in cevabını taşıyarak 3 bayt kaydedildi.

C (gcc) , 20 bayt

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

Çevrimiçi deneyin!

ARA , 50 bayt

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

INTERCAL'lerin unary operatörleri bunun için oldukça uygundur, bu yüzden ilk yazımı yazmaya karar verdim.

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

Haskell , 33 bayt

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

Çevrimiçi deneyin!

0 indeksleme kullanır.

Jöle , 7 6 bayt

Outgolfer Erik'e 1 bayt teşekkürler.

Bt0ṖṪṆ

Çevrimiçi deneyin!

Daha uzun programlar

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

,,, , 10 9 bayt

::0-&2*&¬

açıklama

Örneğin, girişi 3 olarak alı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 bayt

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

Çevrimiçi deneyin!

Boolean çıkışı.

Oktav , 34 bayt

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

Çevrimiçi deneyin!

Açıklama:

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

Gönderme:

Python 2 , 41 39 bayt

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

Çevrimiçi deneyin!

FryAmTheEggman sayesinde -2 bayt

İlk Çözüm:

Python 2 , 43 bayt

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

Çevrimiçi deneyin!

Matl , 11 10 bayt

t4*YF1)Z.~

Çevrimiçi deneyin! Veya ilk 100 çıkışı görün .

açıklama

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 bayt

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

Kronecker sembolünü kullanarak .

Çevrimiçi deneyin!

Befunge-98 , 19 bayt

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

Çevrimiçi deneyin!

&#                       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?) Karakter, 99 (78?) Bayt

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

igiriş nerede .

Gördüğünüz gibi sıfıra bakmazsam 21 byte tasarruf ediyorum (yazarın test durumunda yaptığı gibi):

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

Bu benim ilk codegolf bu yüzden umarım iyi yaptım :)

Çevrimiçi deneyin! Lol hesaplamak oldukça uzun olmasına rağmen.

C (GCC) , 35 31 bayt

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

Özyinelemeli bir uygulamaya geçti. Çevrimiçi deneyin!

Java 8, 17 bayt

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

LeakyNun'un Python 3 cevabının basit limanı . Daha kısa bir çözüm görmek için bitsel işlemler ve operatör önceliği konusunda yeterince bilgi sahibi değilim; belki fazladan parantezden kaçınmanın bir yolu var mı?

Japt , 10 8 9 bayt

!+¢g¢a1 É

Çevrimiçi deneyin!

açıklama

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

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

PHP> = 7.1, 32 bayt

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

PHP Sandbox Çevrimiçi

PHP , 40 bayt

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

Çevrimiçi deneyin!

PHP , 41 bayt

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

Çevrimiçi deneyin!

Ortak Lisp, 56 bayt

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

Çevrimiçi deneyin!

Çip , 93 bayt

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

Girdiyi küçük endian bayt olarak alır. (TIO'da bunu sizin için yapan bir miktar python var). Çıktıyı 0x0veya olarak verir 0x1. (TIO, değeri incelemek için xxd kullanır).

Çevrimiçi deneyin!

Bu nasıl?

Chip her seferinde bir byte'a bakıyor, bu yüzden çok baytlı girişleri kullanmak biraz topluyor, ama korktuğum kadar yakın değil.

Hadi içine girelim:

HZABCDEFG

Bunlar HZ , önceki baytın yüksek bit (varsa biri) ve A- Ggüncel byte yedi alt biti. Bunlar, sayının en düşük ayarlanan bitini bulmak için kullanılır.

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

En düşük ayar biti bulunduğunda, yapmamız gereken birkaç şey var. Bu ilk yığın derhal "eğer belli bir parçamız varsa) ler) varsa, sonra Sda çıktıyı tbastırmayı bırak ve cevabı bastırdıktan sonra etkisizleş.

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

Geçerli bayttan ( A- H) hangisi bitse bir kaç sıfırdan önce gelir, sonra bir tane ( \ve /: bunlar doğrudan kuzeyin bitlerine bakar; önceki tüm bitlerin sıfır olduğuna emin olabiliriz) doğru ( v,' ...), o zaman hangi değeri ters çevrilir ve çıktının düşük biti ( ~a) olarak verilir.