23

ड्रैगन वक्र अनुक्रम (या नियमित रूप से कागज तह अनुक्रम) एक द्विआधारी अनुक्रम है। a(n)कम से कम 1 महत्वपूर्ण बिट के बाईं ओर से दिया गया है n। उदाहरण के लिए गणना करने के लिए a(2136)हम पहले बाइनरी में परिवर्तित होते हैं:

100001011000

हम अपने कम से कम महत्वपूर्ण बिट पाते हैं

100001011000
        ^

बिट को इसके बाईं ओर ले जाएं

100001011000
       ^

और उसका नकार लौटा दो

कार्य

इनपुट, आउटपुट के रूप में एक सकारात्मक पूर्णांक दिया 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

code-golf sequence binary code-golf ascii-art probability-theory

— गेहूं का जादूगर
स्रोत

किसी से संबंधित

— nimi

9

कम से कम महत्वपूर्ण बिट 100001011000एक है 0। क्या आपका मतलब कम से कम महत्वपूर्ण है 1?

— बिखेरना

16

गणितज्ञ 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,#]][[#]]&

— केली लोडर
स्रोत

3

वाह! एक गणितज्ञ उत्तर और यह केवल बनाया नहीं है। एक उत्थान है!

— KeyWeeUsr

2

केवल एक चीज जो इस जवाब को और बेहतर बना सकती है, वह क्यों और कैसे काम करती है, इसके लिए एक स्पष्टीकरण है। : पी

— मार्टिन एंडर

2

@MartinEnder arxiv.org/pdf/1408.5770.pdf टिप्पणी देखें के बाद उदाहरण 13.

— alephalpha

7

पायथन 3 , 22 21 बाइट्स

1 बाइट ETHproductions के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

बिटवाइज अंकगणित ftw।

— लीक नन
स्रोत

2

"आप पूर्णांक या बूलियन द्वारा आउटपुट कर सकते हैं" तो मुझे लगता है कि आपको इसकी आवश्यकता नहीं है 0+(...)?

— मार्टिन एंडर

यहां संचालन का क्रम वास्तव में मुझे भ्रमित कर रहा है। n&1कोष्ठक में रखा जा सकता है? या यह 1+(n^~-n)<1कि कोष्ठक में रखा जा सकता है? या यह है 1+(n^~-n)...

— ETHproductions

हे भगवान क्या? यह वही है जो मैं देख रहा था: ओ अच्छा!

— हाइपरनेत्रिनो

&सबसे कम पूर्वता है, इसलिए यह है1+(n^~-n)

— लीक नून

आह, पूर्ववर्ती तालिका मिली। अब यह सब समझ में आता है: P

— ETHproductions

6

रेटिना ,38 34 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मार्टिन और लीकी अनिवार्य रूप से 5 और बाइट्स के लिए इस विचार के साथ आए थे!

इनपुट को एकीकृत करने के लिए परिवर्तित करता है, और फिर उत्तरोत्तर संख्या को 2 से विभाजित करता है। एक बार जब यह समान रूप से नहीं कर सकता है (यानी संख्या विषम है) तो यह इनपुट से 4 के पैच को हटा देता है, अंतिम ऑपरेशन मॉड 4 के परिणाम की गणना करता है अंत में, यह जाँचता है कि क्या परिणाम 1 था, जिसका अर्थ है कि सबसे कम महत्वपूर्ण 1 बिट के बाईं ओर अंक शून्य था। यदि यह सच है, तो अंतिम परिणाम 1 है, अन्यथा यह शून्य है।

— FryAmTheEggman
स्रोत

31 बाइट्स (क्या मुझे इसे स्वयं पोस्ट करना चाहिए?)

— लीक नून

मुझे पूर्ण द्विआधारी रूपांतरण से बचने और केवल 2 के कारकों को विभाजित करने और 1 (mod 4) के साथ समानता की जांच करने का एक तरीका मिला: tio.run/##K0otycxL/…

— मार्टिन

@MartinEnder अनिवार्य रूप से मेरा एल्गोरिथ्म ... 2 बाइट्स के साथ

— लीक नून

@LeakyNun ओह, हाँ, वे दोनों एक ही विचार हैं। महान दिमाग और सामान ...;)

— मार्टिन एंडर

मैं इसे संपादित करूंगा, लेकिन यदि आप में से कोई इसे पोस्ट करना चाहता है तो मैं इसे वापस

— लाऊंगा

6

जेली , 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.

— डेनिस
स्रोत

4

ऐलिस , 8 बाइट्स

I2z1xnO@

इसे ऑनलाइन आज़माएं!

एक यूनिकोड वर्ण के कोड बिंदु के रूप में इनपुट लेता है और परिणाम को 0x00 या 0x01 बाइट के अनुसार परिणाम देता है।

परीक्षण क्षमता के लिए, यहां 12 बाइट्स पर एक दशमलव I / O संस्करण है जो सटीक एक ही एल्गोरिथ्म का उपयोग करता है (केवल I / O अलग है):

/o
\i@/2z1xn

इसे ऑनलाइन आज़माएं!

यदि ऐलिस एक गोल्फ भाषा थी और मुझे स्पष्ट रूप से I / O और प्रोग्राम समाप्ति की आवश्यकता नहीं थी, तो यह 2z1xn05AB1E और जेली दोनों को हराते हुए मात्र 5 बाइट्स ( ) में होता था।

व्याख्या

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.

— मार्टिन एंडर
स्रोत

3

05AB1E , 6 बाइट्स

b0Ü¨θ≠

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

3

समझदार , 28 20 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

यह लीक नून के पायथन जवाब का एक बंदरगाह है। यह दुर्भाग्य से टीआईओ पर काम नहीं करता है क्योंकि टीआईओ के दुभाषिया का संस्करण थोड़ा पुराना है।

हम अपने इनपुट की 3 प्रतियाँ बनाने के साथ शुरू करते हैं ::, फिर हम 1. द्वारा शीर्ष प्रति को घटाते हैं। यह पहली तक सभी बिट्स को फ्लिप करेगा। फिर हम अपने इनपुट की एक और कॉपी के साथ इसे जमा करते हैं। चूँकि हमारे इनपुट पर पहले 1 तक सभी बिट्स फ़्लिप हो चुके हैं, इस कारण उन सभी बिट्स के परिणाम 1 हो जाएंगे। यदि हम फिर ~-परिणाम में एक जोड़ते हैं, तो हमें अपने कम से कम महत्वपूर्ण के बाईं ओर एक एकल 1 मिलेगा । हम और यह इनपुट से उस बिट को प्राप्त करने के लिए इनपुट के साथ। अब हमारे पास 0iff होगा अगर वह बिट ऑफ था और 2 iff की शक्ति चालू थी, तो हम इसे एक 1या एक के 0साथ बदल सकते हैं :[?>]। एक बार जब यह हो जाता है तो हमें केवल थोड़ा सा नकारने की जरूरत होती है ~-^और हम पूरी हो जाती हैं।

— गेहूं का जादूगर
स्रोत

3

पायथन 2 , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

3

हास्केल , 45 43 39 बाइट्स

6 बाइट्स ने निम्मी को धन्यवाद दिया

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

इसे ऑनलाइन आज़माएं!

— गेहूं का जादूगर
स्रोत

आप उपयोग कर सकते हैं divके बजाय quot।

— नमि

और भी बेहतर: divMod:f x|(d,m)<-divMod x 2=[mod(1+d)2,f d]!!m

— nimi

@ नमि मुझे समझ में भी नहीं आता कि यह कैसे काम करता है। आपको शायद इसे स्वयं पोस्ट करना चाहिए।

— गेहूं जादूगर

यह अभी भी एक ही एल्गोरिदम है, लेकिन शाखा को लेने का एक अलग तरीका है (पुनरावर्ती कॉल फिर से बनाम बेस केस), इसलिए इसे संपादित करने के लिए स्वतंत्र महसूस करें और इसे बांधने के लिए और करने के लिए |(d,m)<-divMod x 2एक पैटर्न गार्ड है । हम दो तत्व सूची को अनुक्रमित करने के लिए उपयोग करते हैं । मामले में की हम वापसी और के मामले में । ddiv x 2mmod x 2m[...,...]!!mm==0mod(1+d)2m==1 f d

— nimi

1

ओह, माफ करना, आप सूची तत्वों फ्लिप करने के लिए है: [f d,mod(1+d)2]। इसे ऑनलाइन आज़माएं! ।

— नमि

3

x86 मशीन कोड, १। १६ 15 बाइट्स:

एक ABI मान लेता है जहाँ पैरामीटर स्टैक पर धकेल दिए जाते हैं और रिटर्न मान ALरजिस्टर में होता है।

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

यह इस तरह से disassembled है:

_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

— गोविंद परमार
स्रोत

1

@PeterTaylor मैं अपने जवाब के लिए बाइट्स में सीपीयू निर्देश का आकार गिन रहा हूं; असेंबली के जवाब के लिए PPCG पर यह एक बहुत ही आम बात है।

— गोविंद परमार

1

मैं यह नहीं कह सकता कि यह कितना आम है, लेकिन यह निश्चित रूप से गलत है

— पीटर टेलर

1

यह सिर्फ पांडित्य नहीं है, यह अर्थहीन भी है। जहाँ तक कंप्यूटर का सवाल है, "मशीन कोड" और "असेंबली कोड" में कोई अंतर नहीं है। अंतर केवल व्याख्या का एक है। हम मनुष्यों को पढ़ना आसान बनाने के लिए मशीन कोड बाइट्स के लिए mnemonics प्रदान करते हैं। दूसरे शब्दों में, हम उन्हें समझने में आसान बनाने के लिए बाइट्स को अनफॉल्ग करते हैं।

— कोडी ग्रे

3

यह अप्रासंगिक है, @ पेटर। असेंबली कोड मशीन कोड का मानव-पठनीय अनुवाद है। वे बिल्कुल एक ही भाषा हैं, सिर्फ दो अलग-अलग रूपों / अभ्यावेदन में। यह TI BASIC से अलग नहीं है, जहां आमतौर पर यह स्वीकार किया जाता है कि हम चरित्र बाइट्स के बजाय टोकन गिनते हैं , क्योंकि यह है कि सिस्टम उन्हें आंतरिक रूप से कैसे संग्रहीत करता है। असेंबली लैंग्वेज के साथ भी यही होगा: इंस्ट्रक्शन मेमोनीक्स को व्यक्तिगत वर्णों के रूप में संग्रहीत नहीं किया जाता है, बल्कि समतुल्य मशीन कोड के बाइट्स के रूप में दर्शाया जाता है।

— कोडी ग्रे

2

इसके अलावा, व्यावहारिक रूप से, कोई भी कोड-गोल्फ प्रतियोगिता में विस्तारित असेंबली भाषा सम्मोहन क्यों दर्ज करेगा , जब वे उन्हें 100% समकक्ष मशीन कोड में बदल सकते हैं, जहां प्रवेश मुफ्त में छोटा होने की गारंटी है? अकेले ही दो बिंदुओं के बीच अंतर करता है, अगर पूरी तरह से बेतुका नहीं है।

— कोडी ग्रे

3

जावास्क्रिप्ट (ईएस 6), 17 14 बाइट्स

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

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

स्निपेट का विस्तार करें

संपादित करें: एक बार मैंने देखा कि बूलियन आउटपुट स्वीकार्य था, तो @ डेनिस के उत्तर को पोर्ट करके 3 बाइट्स सहेजे गए।

— नील
स्रोत

3

सी (जीसीसी) , 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— डेनिस
स्रोत

यह वास्तव में "काम" नहीं करता है; आप एक विशेष आर्किटेक्चर को लक्षित करने वाले कंपाइलर के एक विशेष संस्करण के लिए कोड जनरेटर के एक क्विक पर भरोसा कर रहे हैं, जहां मध्यवर्ती गणना उसी रजिस्टर में की जाती है जो रिटर्न मानों के लिए उपयोग किया जाता है। किसी भी प्रकार के अनुकूलन को सक्षम करना, लक्ष्य वास्तुकला को बदलना या जीसीसी के एक अलग संस्करण का उपयोग करना इसे तोड़ देगा। आप यह भी कह सकते हैं कि "13 अक्टूबर को पूर्णिमा होने पर मेरे ढेर पर कचरा सही आउटपुट होता है"।

— कोड़ी ग्रे

जबकि आप जो कुछ भी कहते हैं वह सच है और इस तरह का कोड कभी भी उत्पादन कोड में उपयोग नहीं किया जाता है, हम भाषाओं को कोड गोल्फ के उद्देश्यों के लिए उनके कार्यान्वयन द्वारा परिभाषित करते हैं। अतिरिक्त झंडे के बिना, यह gcc और tcc के सभी हाल के संस्करणों में काम करता है, और इसे केवल एक संस्करण में काम करना होगा जिसे वैध माना जाए।

— डेनिस

"हम कोड गोल्फ के उद्देश्यों के लिए उनके कार्यान्वयन द्वारा भाषाओं को परिभाषित करते हैं" रुको, क्या? तो प्रत्येक संकलक ध्वज और GCC का हर संस्करण एक अलग भाषा को परिभाषित करता है? तुम्हें पता है कि पागल है, है ना? C भाषा मानक वह है जो भाषा को परिभाषित करता है।

— कोड़ी ग्रे

यहाँ नहीं। यदि कोई सी मानक था, लेकिन कोई कार्यान्वयन नहीं है, तो हम इसे एक भाषा भी नहीं मानेंगे। जैसा कि मैंने पहले कहा, संकलक भाषा को परिभाषित करता है । नतीजतन, अपरिभाषित व्यवहार पर भरोसा करने की अनुमति है । झंडे के एक अलग सेट को एक अलग भाषा नहीं माना जाता है, लेकिन जब तक आप उन्हें अपनी बाइट में नहीं जोड़ते, तब तक सभी जवाब मानक संकलन झंडे का उपयोग करते हैं।

— डेनिस

वाह। ये पागल है। मेरा मतलब है, मैं समझ सकता हूं कि क्या आप कह रहे हैं कि कार्यान्वयन-परिभाषित व्यवहार की अनुमति है, लेकिन अपरिभाषित व्यवहार कार्यान्वयन द्वारा परिभाषित नहीं है। यह वस्तुतः अपरिभाषित है। कार्यान्वयन को हर बार यादृच्छिक चीजें करने की अनुमति दी जाती है। और "मानक संकलन झंडे" की यह धारणा कुछ ऐसा है जिसे आपने अभी आविष्कार किया है। मेरे मानक संकलन झंडों में कई ऐसे शामिल हैं जो आपके कोड को तोड़ते हैं। और मुझे शायद ही लगता है कि अनुकूलक गैर-मानक है। खैर, स्पष्ट रूप से यह साइट मेरे लिए नहीं है।

— कोडी ग्रे

3

INTERCAL , 50 बाइट्स

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

INTERCALs यूनिरी ऑपरेटर्स इसके लिए काफी उपयुक्त हैं, इसलिए मैंने अपनी पहली पोस्ट लिखने का फैसला किया।

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

— बेरंड फिशर
स्रोत

3

हास्केल , 33 बाइट्स

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

इसे ऑनलाइन आज़माएं!

0-इंडेक्सिंग का उपयोग करता है।

— एंडर्स कसीगोर
स्रोत

1

~इस संदर्भ में क्या करता है? मुझे लगता है कि यह एक आलसी मैच है, लेकिन आपको एक आलसी मैच की आवश्यकता क्यों है?

— गेहूं जादूगर

2

जेली , 7 6 बाइट्स

1 बाइट धन्यवाद करने के लिए एरिक आउटगोल्फर।

Bt0ṖṪṆ

इसे ऑनलाइन आज़माएं!

लंबे कार्यक्रम

7 बाइट्स: Họ¡2&2Ị
7 बाइट्स: Bt0ṫ-ḄỊ

— लीक नन
स्रोत

हम्म ... ठीक है, आप ṖṪṆइसके बजाय बस (मेरे हटाए गए जवाब के रूप में) कर सकते हैं ṫ-ḄỊ।

— एर्ग आउटफोलर

1

आपकी 7-बाइट सूची के लिए एक और एक:BUḌDḊḢ¬

— steenbergh

2

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

— totallyhuman
स्रोत

2

हास्केल , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बूलियन आउटपुट।

— XNOR
स्रोत

2

ऑक्टेव , 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

— स्टीवी ग्रिफिन
स्रोत

मैं डी 2 बी के बारे में कभी नहीं सुनता ...: ओ

— सैनचाइज़्स

1

प्रस्तुत करने:

पायथन 2 , 41 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-2 बाइट्स फ्राइअमईएग्गमैन को धन्यवाद

प्रारंभिक समाधान:

पायथन 2 , 43 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— HyperNeutrino
स्रोत

तो आपका कौन सा सबमिशन है?

— लीक नून

@LeakyNun पहला छोटा होने के कारण; दूसरा मेरा मूल सबमिशन था। क्या मुझे उन्हें अलग से पोस्ट करना चाहिए?

— हाइपरनेत्रिनो

~-x&1मुझे लगता है कि जबकि हालत के लिए काम करता है।

— FryAmTheEggman 15:28

(मैं उपयोगकर्ता नाम भूल गया); मैंने आपके संपादन को अस्वीकार कर दिया क्योंकि PPCG पर अन्य लोगों के कोड को संपादित करने की सलाह नहीं दी गई है। आप सुझाव (btw, धन्यवाद @FryAmTheEggman) पोस्ट कर सकते हैं, लेकिन कृपया गोल्फ संपादन न करें। धन्यवाद!

— हाइपरनेत्रिनो

@StewieGriffin आह हाँ, धन्यवाद। दुर्भाग्य से मैं उपयोगकर्ता को पिंग नहीं कर सकता क्योंकि संपादन अस्वीकार कर दिया गया था।

— हाइपरनेत्रिनो

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

— लुइस मेंडो
स्रोत

1

परी / जीपी , 20 बाइट्स

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

क्रॉकर प्रतीक का उपयोग करना ।

इसे ऑनलाइन आज़माएं!

— alephalpha
स्रोत

1

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

— OVS
स्रोत

1

SCALA, 99 (78?) Chars, 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)

यह मेरा पहला कोडगोल्फ है इसलिए मुझे आशा है कि मैंने अच्छा किया :)

इसे ऑनलाइन आज़माएं! हालांकि यह योग्य गणना करने के लिए काफी लंबा है।

— वी। कोर्टीस
स्रोत

साइट पर आपका स्वागत है!

— DJMcMayhem

1

सी (जीसीसी) , 35 31 बाइट्स

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

एक पुनरावर्ती कार्यान्वयन पर स्विच किया गया। इसे ऑनलाइन आज़माएं!

— ceilingcat
स्रोत

1

जावा 8, 17 बाइट्स

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

LeakyNun के पायथन 3 उत्तर का सीधा पोर्ट । मैं एक छोटे से समाधान को देखने के लिए बिटवाइज़ संचालन और ऑपरेटर पूर्वता के साथ पर्याप्त रूप से परिचित नहीं हूं; शायद अतिरिक्त कोष्ठक से बचने का एक तरीका है?

— जॉली विदूषक
स्रोत

0

जाप , 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

— ल्यूक
स्रोत

यह falseसब कुछ के लिए लौटता है क्योंकि चरित्र (0 या 1) हमेशा एक स्ट्रिंग है।

— शैगी

उफ़, ध्यान दिया जाना चाहिए ... अब ठीक है

— ल्यूक

ऐसा लगता है कि यह अभी के लिए विफल रहता है1 ।

— शगुन

0

जावास्क्रिप्ट (ईएस 6), 53 34 बाइट्स

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

— ल्यूक
स्रोत

42 बाइट्स:a=>!+(a=a.toString(2))[a.lastIndexOf(1)-1]

— झबरा

मुझे पहले से ही एक छोटा (गणितीय) समाधान मिला ...

— ल्यूक

अच्छा :) मन अगर मैं उस 42 बाइट एक पोस्ट?

— शैगी

@ शैगी, बिल्कुल नहीं

— ल्यूक

0

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

इसे ऑनलाइन आज़माएं!

— जार्ग हुल्सरमैन
स्रोत

0

आम लिस्प, 56 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— रेंज़ो
स्रोत

0

चिप , 93 बाइट्स

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

थोड़ा एंडियन बाइट्स के रूप में इनपुट लेता है। (TIO के पास थोड़ा सा अजगर है जो आपके लिए ऐसा करता है)। 0x0या तो आउटपुट देता है 0x1। (TIO मान का निरीक्षण करने के लिए xxd का उपयोग करता है)।

इसे ऑनलाइन आज़माएं!

यह कैसे करते हैं?

चिप एक बार में एक बाइट को इनपुट के रूप में देखता है, इसलिए मल्टीबाइट इनपुट को संभालते हुए कुछ बल्क जोड़ता है, लेकिन उतना नहीं जितना कि मुझे डर था।

आइए इसमें चलते हैं:

HZABCDEFG

ये HZपिछले बाइट के उच्च बिट हैं (अगर वहाँ एक था), और A- G, वर्तमान बाइट के सात निचले बिट्स। इनका उपयोग संख्या के सबसे कम सेट बिट का पता लगाने के लिए किया जाता है।

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

जब सबसे कम सेट बिट पाया जाता है, तो हमारे पास करने के लिए कुछ चीजें होती हैं। यह पहला हिस्सा कहता है, "अगर हमारे पास एक सेट बिट ( )'s) है, तो Sआउटपुट को ऊपर नीचे करना बंद कर दें, और tजवाब प्रिंट करने के बाद erminate करें।

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

वर्तमान बाइट ( A- H) में से जो भी केवल जीरो के एक समूह से पहले होता है, तो एक ( \और /: ये बिट्स को सीधे उनके उत्तर की ओर देखते हैं; हम भरोसा कर सकते हैं कि पिछले सभी बिट शून्य थे) तारों के माध्यम से पारित हो गए हैं दाईं ओर ( v, '...), फिर जो भी इसे उल्टा किया जाता है उसे आउटपुट के कम बिट ( ~a) के रूप में दिया जाता है ।

— Phlarx
स्रोत