47

प्राचीन यूनानियों के पास ये बातें अकेले और दोगुनी संख्या में थीं। एक समान रूप से संख्या का एक उदाहरण 14. यह एक बार 2 से विभाजित किया जा सकता है, और उस बिंदु पर एक विषम संख्या (7) बन गई है, जिसके बाद यह 2 से विभाज्य नहीं है। एक दोगुना सम संख्या 20 है। इसे 2 बार 2 से विभाजित किया जा सकता है, और फिर 5 हो जाता है।

आपका कार्य एक फ़ंक्शन या प्रोग्राम लिखना है जो एक पूर्णांक को इनपुट के रूप में लेता है, और जितनी बार संभव हो उतने बाइट में, पूर्णांक के रूप में 2 से विभाज्य होता है। इनपुट एक गैर-पूर्णांक पूर्णांक (कोई भी सकारात्मक या नकारात्मक मान, आपकी भाषा की सीमा के भीतर) होगा।

परीक्षण के मामलों:

14 -> 1

20 -> 2

94208 -> 12

7 -> 0

-4 -> 2

कम से कम बाइट के साथ जवाब जीतता है।

युक्ति: संख्या को आधार में परिवर्तित करने का प्रयास करें 2. देखें कि आपको क्या बताता है।

code-golf number division

— गस्ट वैन डे वाल
स्रोत

11

@AlexL। आप यह भी देख सकते हैं कि यह कभी विषम नहीं हो रहा है, इसलिए असीम रूप से भी। अगर स्टैक ओवरफ्लो की अनुमति दी जाती है तो मैं कुछ बाइट्स बचा सकता हूं;)

— जॉयोबिट्स

1

The input will be a nonzero integerक्या शून्य को संभावित इनपुट होने के बारे में आपकी टिप्पणी के बाद इसे संपादित करने की आवश्यकता है?

— ट्राइकोप्लाक्स

2

इसे 2-एडिक वैल्यूएशन या 2-एडिक ऑर्डर कहा जाता है।

— पॉल

7

वैसे, विकिपीडिया के अनुसार, 0 का p-adic मूल्यांकन अनंत के रूप में परिभाषित किया गया है।

— पॉल

3

कितना अजीब सवाल है!

— corsiKa

23

जेली , 4 बाइट्स

Æfċ2

जेली के नवीनतम संस्करण में, ÆEḢ(3 बाइट्स) काम करता है।

Æf      Calculate the prime factorization. On negative input, -1 appended to the end.
  ċ2    Count the 2s.

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

यह नकारात्मक इनपुट के लिए भी काम करता है।

— lirtosiast

1

@ThomasKwa मुझे नहीं लगता कि मायने रखता है। शायद एक मेटा सवाल?

— orlp

ठीक नहीं है? यह वास्तव में विषम संख्याओं के लिए 0 आउटपुट देता है।

— बुसुकुआन २

@busukxuan यह uk 1 के लिए काम नहीं करता है।

— lirtosiast

1

@ टायज़ॉइड जेली डिफ़ॉल्ट रूप से ऑफ़लाइन दुभाषिया पर अपने स्वयं के कोड पृष्ठ का उपयोग करता है , जिसमें एक चार बाइट है।

— 20

93

x86_64 मशीन कोड, 4 बाइट्स

BSF (बिट स्कैन फॉरवर्ड) निर्देश बिल्कुल यही करता है !

0x0f    0xbc    0xc7    0xc3

जीसीसी शैली विधानसभा में, यह है:

    .globl  f
f:
    bsfl    %edi, %eax
    ret

इनपुट EDI रजिस्टर में दिया गया है और EAX रजिस्टर में मानक 64-बिट c कॉलिंग कन्वेंशन के अनुसार दिया गया है।

दो पूरक बाइनरी एन्कोडिंग के कारण, यह -ve के साथ-साथ वी + संख्याओं के लिए भी काम करता है।

इसके अलावा, दस्तावेज़ के यह कहने के बावजूद कि "यदि स्रोत ऑपरेंड की सामग्री 0 है, तो गंतव्य ऑपरेंड की सामग्री अपरिभाषित है।" , मैं अपने उबंटू वीएम पर पाता हूं कि आउटपुट f(0)0 है।

निर्देश:

ऊपर के रूप में सहेजें evenness.sऔर साथ इकट्ठाgcc -c evenness.s -o evenness.o
निम्न परीक्षण चालक को सहेजें evenness-main.cऔर इसके साथ संकलित करें gcc -c evenness-main.c -o evenness-main.o:

#include <stdio.h>

extern int f(int n);

int main (int argc, char **argv) {
    int i;

    int testcases[] = { 14, 20, 94208, 7, 0, -4 };

    for (i = 0; i < sizeof(testcases) / sizeof(testcases[0]); i++) {
        printf("%d, %d\n", testcases[i], f(testcases[i]));
    }

    return 0;
}

फिर:

संपर्क: gcc evenness-main.o evenness.o -o evenness
Daud: ./evenness

@FarazMasroor ने इस बारे में अधिक जानकारी मांगी कि यह उत्तर कैसे प्राप्त हुआ।

मैं के साथ और अधिक परिचित हूँ सी 86 की पेचीदगियों को विधानसभा से है, तो आम तौर पर मैं एक संकलक का उपयोग मेरे लिए विधानसभा कोड उत्पन्न करने के लिए। मैं अनुभव से जानता हूं कि gcc एक्सटेंशन जैसे कि __builtin_ffs(), __builtin_ctz()और__builtin_popcount() आमतौर पर x86 पर 1 या 2 निर्देशों को संकलित करना और इकट्ठा करना। इसलिए मैंने सी फ़ंक्शन के साथ शुरुआत की:

int f(int n) {
    return __builtin_ctz(n);
}

ऑब्जेक्ट कोड के लिए सभी तरह से नियमित gcc संकलन का उपयोग करने के बजाय, आप -Sकेवल असेंबली करने के लिए विकल्प का उपयोग कर सकते हैं - gcc -S -c evenness.c। यह evenness.sइस तरह एक विधानसभा फ़ाइल देता है :

    .file   "evenness.c"
    .text
    .globl  f
    .type   f, @function
f:
.LFB0:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    movl    %edi, -4(%rbp)
    movl    -4(%rbp), %eax
    rep bsfl    %eax, %eax
    popq    %rbp
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
.LFE0:
    .size   f, .-f
    .ident  "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
    .section    .note.GNU-stack,"",@progbits

इस का एक बहुत बाहर निकाला जा सकता है। विशेष रूप से हम जानते हैं कि हस्ताक्षर के साथ कार्यों के लिए सी कॉलिंग सम्मेलनint f(int n); अच्छा और सरल है - इनपुट परम को EDIरजिस्टर में पारित किया जाता है और रजिस्टर में रिटर्न वैल्यू लौटा दी जाती है EAX। इसलिए हम अधिकांश निर्देश निकाल सकते हैं - उनमें से बहुत से रजिस्टरों को बचाने और एक नया स्टैक फ्रेम स्थापित करने से चिंतित हैं। हम यहां स्टैक का उपयोग नहीं करते हैं और केवल EAXरजिस्टर का उपयोग करते हैं, इसलिए अन्य रजिस्टरों के बारे में चिंता करने की आवश्यकता नहीं है। यह "गोल्फ" विधानसभा कोड छोड़ देता है:

    .globl  f
f:
    bsfl    %edi, %eax
    ret

@Zwol के अनुसार ध्यान दें, आप समान परिणाम प्राप्त करने के लिए अनुकूलित संकलन का भी उपयोग कर सकते हैं। विशेष रूप -Osसे उपरोक्त निर्देशों (कुछ अतिरिक्त कोडांतरक निर्देशों के साथ, जो किसी भी अतिरिक्त ऑब्जेक्ट कोड का उत्पादन नहीं करते हैं) का उत्पादन करता है।

यह अब के साथ इकट्ठा किया गया है gcc -c evenness.s -o evenness.o, जिसे बाद में ऊपर वर्णित के रूप में एक परीक्षण चालक कार्यक्रम में जोड़ा जा सकता है।

इस विधानसभा के अनुरूप मशीन कोड निर्धारित करने के कई तरीके हैं। मेरा पसंदीदा gdb disassdisassembly कमांड का उपयोग करना है:

$ gdb ./evenness
GNU gdb (Ubuntu 7.7.1-0ubuntu5~14.04.2) 7.7.1
...
Reading symbols from ./evenness...(no debugging symbols found)...done.
(gdb) disass /r f
Dump of assembler code for function f:
   0x00000000004005ae <+0>: 0f bc c7    bsf    %edi,%eax
   0x00000000004005b1 <+3>: c3  retq   
   0x00000000004005b2 <+4>: 66 2e 0f 1f 84 00 00 00 00 00   nopw   %cs:0x0(%rax,%rax,1)
   0x00000000004005bc <+14>:    0f 1f 40 00 nopl   0x0(%rax)
End of assembler dump.
(gdb)

इसलिए हम देख सकते हैं कि bsfनिर्देश के लिए मशीन कोड है 0f bc c7और retहै c3।

— डिजिटल आघात
स्रोत

क्या हम इसे 2 नहीं मानते हैं?

— lirtosiast

2

मैं मशीन भाषा / बाइट डंप कोड कैसे सीखूं? ऑनलाइन कुछ भी नहीं पा सकते हैं

— Faraz Masroor

1

यह सी कॉलिंग कन्वेंशन को संतुष्ट नहीं करता है। X86-32 पर, स्टैक पर तर्क पारित किया जाता है; x86-64 पर, तर्क% rdi में पारित किया गया है। यह केवल आपके टेस्ट हार्नेस के भीतर काम करता प्रतीत होता है क्योंकि आपका कंपाइलर% ex में तर्क की एक बासी प्रति छोड़ देता है। यदि आप evenness-main.cविभिन्न अनुकूलन सेटिंग्स के साथ दोहन को संकलित करते हैं तो यह टूट जाएगा ; मेरे लिए यह साथ टूट जाता है -O, -O2या -O3।

— एंडर्स कासोर्ग

1

@AndersKaseorg - इसे इंगित करने के लिए धन्यवाद। मैंने इसे अभी x86_64 पर सीमित कर दिया है, ताकि इनपुट RDI में आए।

— डिजिटल ट्रामा

3

"इसके अलावा, दस्तावेज कहने के बावजूद [...]" - आपको जो भी मूल्य मिलता है, वह आवश्यक रूप से प्रलेखन से सहमत है। यह अन्य प्रोसेसर मॉडल को आपकी तुलना में एक अलग मूल्य देने से इंकार नहीं करता है।

— hvd

25

पायथन, 25 बाइट्स

lambda n:len(bin(n&-n))-3

n & -n कम से कम महत्वपूर्ण बिट को छोड़कर कुछ भी शून्य, जैसे यह:

100010101010100000101010000
            v
000000000000000000000010000

हम अनुगामी शून्य की संख्या में रुचि रखते हैं, इसलिए हम इसे बाइनरी स्ट्रिंग का उपयोग करके परिवर्तित करते हैं bin, जो उपरोक्त संख्या के लिए होगा "0b10000"। चूँकि हम इसकी परवाह नहीं करते हैं 0b, न ही 1, हम उस तार की लंबाई से 3 घटाते हैं।

— orlp
स्रोत

अपना उत्तर पोस्ट करने के बाद मुझे लगा कि आप बहुत स्मार्ट हैं, इसलिए मैंने इसे पाइथ में बदलने और यह देखने की कोशिश की कि क्या आप मेरी तुलना में छोटे थे। इसने l. (बिन (_)) के बजाय log2 का उपयोग करते हुए l। और Q_Q का उत्पादन किया। यह मेरे पाइथ उत्तर के साथ-साथ एक और पाइथ उत्तर के समान था, ऐसा लगता है कि यह पाइथ में 6 बाइट्स से कम नहीं है ...

— बसुकक्सुआन

21

अजगर, 6 बाइट्स

/P.aQ2

इसे यहाँ आज़माएँ ।

 P.aQ         In the prime factorization of the absolute value of the input
/    2        count the number of 2s.

— lirtosiast
स्रोत

15

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

n=>Math.log2(n&-n)

4 बाइट्स से कम 31-Math.clz32। हा।

— पैट्रिक रॉबर्ट्स
स्रोत

1

अरे वाह, और मैंने हाल ही में इसके बारे में Math.clz32भी सीखा ...

— नील

1

लानत है मैं यह पोस्ट करने जा रहा था! +1

— साइओस

13

जावास्क्रिप्ट ईएस 6, 22 19 बाइट्स

f=x=>x%2?0:f(x/2)+1

लगता है कि पुनरावृत्ति सबसे छोटा मार्ग है।

— ETHproductions
स्रोत

अरे नहीं! तुमने मुझे पराजित किया! अच्छी तरह से किया :) :)

— कॉनर बेल

6

पायथ, 8 बाइट्स

lec.BQ\1

     Q    autoinitialized to eval(input())
   .B     convert to binary string
  c   \1  split on "1", returning an array of runs of 0s
 e        get the last run of 0s, or empty string if number ends with 1
l         take the length

उदाहरण के लिए, द्विआधारी प्रतिनिधित्व 94208है:

10111000000000000

1एस पर विभाजित करने और परिणामी सरणी के अंतिम तत्व को लेने के बाद , यह बन जाता है:

000000000000

यह 12 शून्य है, इसलिए यह "12-गीत भी है।"

यह x / 2आवश्यक रूप से काम करता है क्योंकि यह x >> 1एक बिटशिफ्ट राइट है 1। इसलिए, एक संख्या केवल 2 से विभाज्य होती है जब एलएसबी होती है 0(ठीक उसी तरह जैसे कोई दशमलव संख्या 10 से विभाज्य होती है जब उसका अंतिम अंक होता है 0)।

— Doorknob
स्रोत

6

05AB1E , 4 5 बाइट्स

अब नकारात्मक संख्याओं का समर्थन करता है। कोड:

Äb1¡g

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

स्पष्टीकरण:

Ä      # Abs(input)
 b     # Convert the number to binary
  1¡   # Split on 1's
    g  # Take the length of the last element

CP-1252 एन्कोडिंग का उपयोग करता है।

— अदनान
स्रोत

6

अजगर, 6 बाइट्स

x_.BQ1

मूल रूप से सिर्फ

convert2BinString(evaluatedInput())[::-1].index("1")

— busukxuan
स्रोत

6

MATL , 5 बाइट्स

Yf2=s

यह सभी पूर्णांकों के लिए काम करता है।

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

Yf      % implicit input. Compute (repeated) prime factors. For negative input
        % it computes the prime factors of the absolute value, except that for
        % -1 it produces an empty array instead of a single 1
2=s     % count occurrences of "2" in the array of prime factors

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

"और अब, कुछ पूरी तरह से अलग के लिए ..."

— बीकर

6

सी, 36 (28) बाइट्स

int f(int n){return n&1?0:f(n/2)+1;}

(गैर-तर्क के रूप में शून्य तर्क के लिए परीक्षण निर्दिष्ट नहीं किया गया था।)

अपडेट (टिप्पणी के जवाब में) : यदि हम K & R स्टाइल फ़ंक्शन घोषणाओं की अनुमति देते हैं, तो हमारे पास 28-बाइट संस्करण हो सकते हैं:

f(n){return n&1?0:f(n/2)+1;}

इस मामले में, हम इस तथ्य पर भरोसा करते हैं कि संकलक दोनों nऔर वापसी प्रकार को परिभाषित करता fहै int। यह फ़ॉर्म हालांकि C99 के साथ चेतावनी उत्पन्न करता है और मान्य C ++ कोड के रूप में संकलित नहीं करता है।

— विक्टर टोथ
स्रोत

यदि आप बदलते हैं int n-> nयह अभी भी वैध सी कोड है और 4 वर्णों को काट देता है।

— जोश

अच्छी बात। मैं यह कहने जा रहा था कि यह C99 के साथ कम से कम एक चेतावनी को ट्रिगर करता है, लेकिन रिटर्न प्रकार को छोड़ देता है। और दोनों सी ++ में त्रुटियों को ट्रिगर करते हैं। इसलिए मैं अपना उत्तर उचित रूप से बदल रहा हूं।

— विक्टर टूथ

5

जावा 7, 39 या शायद 44 बाइट्स

int s(int a){return a%2!=0?0:s(a/2)+1;}

int s(int a){return a%2!=0|a==0?0:s(a/2)+1;}

याय पुनरावृत्ति! मुझे !=एक छोटी तुलना के बजाय इसका उपयोग करना था ताकि यह नकारात्मक इनपुट पर बह न जाए, लेकिन इसके अलावा यह बहुत सीधा है। यदि यह विषम है, तो एक शून्य भेजें। यदि हो भी, तो एक जोड़ें और इसे फिर से करें।

दो संस्करण हैं क्योंकि अभी शून्य के लिए आउटपुट अज्ञात है। जब तक स्टैक ओवरफ्लो न हो जाए, और आउटपुट कुछ भी नहीं होगा, क्योंकि 0 असीम रूप से भी है। दूसरा उत्पादन के लिए एक अच्छा, सुरक्षित, लेकिन संभवत: गणितीय रूप से कठोर 0 नहीं है।

— Geobits
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 20 बाइट्स 19 बाइट्स।

f=x=>~x%2&&1+f(x/2)

यह @nimi द्वारा जावास्क्रिप्ट के लिए हास्केल समाधान का एक बंदरगाह है। यह "शॉर्ट-सर्किट" गुणों का उपयोग करता है, &&जिनमें से यदि यह गलत है (जो इस मामले में है -0) तो इसकी बाईं ओर वापस लौटाता है या कोई दूसरा दाईं ओर लौटाता है। odd x = 0इसलिए लागू करने के लिए हम बाएं हाथ को बनाते हैं, 1 - (x % 2)जो बुलबुले के 0माध्यम से होता है &&, अन्यथा हम पुनरावृत्ति करते हैं 1 + f(x / 2)।

के 1 - (x % 2)रूप (~x) % 2में शेविंग नीचे @Neil के कारण है, और इसमें अजीब संपत्ति है जो उपरोक्त फ़ंक्शन को -0छोटे विषम संख्या के लिए उत्सर्जन करने का कारण बनता है । यह मान जेएस के निर्णय की एक ख़ासियत है कि पूर्णांक IEEE754 युगल हैं; इस प्रणाली में एक अलग है +0और -0जो ===एक दूसरे के लिए जावास्क्रिप्ट में विशेष आवरण हैं । ~ऑपरेटर संख्या है, जो छोटे विषम संख्या के लिए एक नकारात्मक भी संख्या होगी के लिए 32-बिट-साइन्ड-पूर्णांक बिटवाइज़ उलट गणना करता है। ( Math.pow(2, 31) + 1उदाहरण के लिए सकारात्मक संख्या के 0बजाय उत्पादन होता है -0।) 32-बिट-हस्ताक्षरित पूर्णांक के लिए अजीब प्रतिबंध का कोई अन्य प्रभाव नहीं है; विशेष रूप से यह शुद्धता को प्रभावित नहीं करता है।

— सीआर ड्रॉस्ट
स्रोत

~x&1से एक बाइट कम है 1-x%2।

— नील

@ नील बहुत मस्त। यह कुछ हद तक सहज ज्ञान युक्त संपत्ति है, लेकिन मैं इसे वैसे भी ले जाऊँगा।

— सीआर ड्रॉस्ट

4

पर्ल 6, 23 18 बाइट्स

{+($_,*/2...^*%2)}

प्रयोग

> my &f = {+($_,*/2...^*%2)}
-> ;; $_? is raw { #`(Block|117104200) ... }
> f(14)
1
> f(20)
2
> f(94208)
12
> f(7)
0
> f(-4)
2

— हॉटकी
स्रोत

4

रूबी 24 बाइट्स

मेरा पहला कोड गोल्फ सबमिशन (yey!)

("%b"%$*[0])[/0*$/].size

मैं यहाँ कैसे आया :

पहले मैं कोड प्राप्त करना चाहता था जो वास्तव में समस्या के आसपास मेरे सिर को प्राप्त करने के लिए कल्पना को पूरा करता था, इसलिए मैंने बाइट्स की संख्या के संबंध में विधि का निर्माण किया:

def how_even(x, times=1)
  half = x / 2
  if half.even?
    how_even(half, times+1)
  else
    times
  end
end

इस ज्ञान के साथ, मैंने फ़ंक्शन को थोड़ी देर के लूप में फिर से डाल दिया और $*इनपुट के रूप में (ARGV) जोड़ा और विषम होने से पहले संख्या कितनी बार आधी हो गई है, इसकी गिनती के रूप में।

x=$*[0];i=1;while(x=x/2)%2<1;i+=1;end;i

मुझे इस पर काफी गर्व था और लगभग इसे प्रस्तुत करने से पहले मुझे लगा कि यह सब दो बंटवारे में मेरे लिए थोड़ा द्विआधारी लगता है, एक सॉफ्टवेयर इंजीनियर होने के नाते लेकिन इतना नहीं कि एक कंप्यूटर वैज्ञानिक यह पहली चीज नहीं थी जो दिमाग में उछली।

इसलिए मैंने कुछ परिणाम एकत्र किए कि इनपुट मान बाइनरी में क्या दिखते हैं:

input      in binary      result
---------------------------------
   14               1110   1
   20              10100   2
94208  10111000000000000  12

मैंने देखा कि परिणाम विषम स्थिति के लिए संख्या के बाईं ओर था, इससे पहले कि संख्या विषम हो जाए।

कुछ सरल स्ट्रिंग जोड़तोड़ करते हुए मैंने 1 की अंतिम घटना पर स्ट्रिंग को विभाजित किया और शेष 0s की लंबाई गिना:

("%b"%$*[0])[/0*$/].size

("%b" % x)किसी संख्या को बाइनरी में बदलने के लिए फ़ॉर्मेटिंग का उपयोग करना, और स्ट्रिंग # स्लाइस को मेरे स्ट्रिंग को स्लाइस करना।

मैंने इस खोज पर रूबी के बारे में कुछ बातें सीखी हैं और जल्द ही और अधिक गोल्फ के लिए तत्पर हैं!

— ryantk
स्रोत

2

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यह एक महान जवाब है; मुझे स्पष्टीकरण पसंद है। +1! यदि आप अधिक कोड-गोल्फ चुनौतियां चाहते हैं, तो कोड-गोल्फ टैग पर क्लिक करें । मैं आपके और उत्तर देखने के लिए उत्सुक हूं।

— wizzwizz4

1

बेझिझक आप मुझसे कोई भी सवाल पूछ सकते हैं। @wizzwizz4मुझे जवाब देने के लिए टिप्पणी की शुरुआत में टाइप करें। (यह सभी यूजरनेम के साथ काम करता है!)

— wizzwizz4

4

जे, 6 बाइट्स

1&q:@|

स्पष्टीकरण:

     |    absolute value
1&q:      exponent of 2 in the prime factorization

— alephalpha
स्रोत

4

सी, 37 बाइट्स

f(int x){return x?x&1?0:1+f(x/2):0;} पुनरावर्ती रूप से अंतिम बिट की जाँच करें जब तक कि यह 0 न हो।

— एंडी सोफ़र
स्रोत

इसके अलावा, f(int n){return __builtin_ctz(n);}अगर आप gcc एक्सटेंशन का उपयोग करने को तैयार हैं। या यहां तक कि#define f __builtin_ctz

— डिजिटल ट्रामा

हटा दें int । यह निहित है, रिटर्न प्रकार की तरह।

— लूज़र ने

@luserdroog, आपका मतलब है f(n){...}? जीसीसी इसे संकलित नहीं करेगा। मैं कोई सी विशेषज्ञ नहीं हूं, लेकिन एक त्वरित खोज से पता चलता है कि शायद यह सुविधा सी के हाल के संस्करणों में हटा दी गई थी। इसलिए शायद यह उचित झंडे के साथ संकलन करेगा?

— एंडी सोफ़र

@AndySoffer मैं देख रहा हूं। शायद -ansiया -gnu99? मुझे पता है कि मैंने इसे काम करने के लिए पा लिया है। मैंने इसके बारे में एक सुझाव उत्तर लिखा है!

— लूसर ने

3

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

f x|odd x=0|1<2=1+f(div x 2)

प्रयोग उदाहरण: f 94208-> 12।

यदि संख्या विषम है, तो परिणाम 0, 1प्लस और आधी संख्या के साथ एक पुनरावर्ती कॉल है।

— nimi
स्रोत

div x 2? क्यों नहीं x/2?

— कैलक्यूलेटरफल

@CatsAreFluffy: हास्केल में बहुत सख्त प्रकार की प्रणाली है। divपूर्णांक विभाजन, /फ्लोटिंग पॉइंट डिवीजन है।

— nimi

3

बेफुज, २०

&:2%#|_\1+\2/#
   @.<

कोड निष्पादन दाएं और रैपिंग के लिए पहली पंक्ति के दूसरे वर्ण के आसपास घूमता रहता है (अनुगामी के लिए धन्यवाद #) 2%आउटपुट तक 1, जिसके कारण _दिशा को बाईं ओर स्विच |करना <पड़ता है , फिर अप करने के लिए, जो दूसरी पंक्ति में चारों ओर लपेटता है , जो आउटपुट और बाहर निकलता है। हम लूप के माध्यम से हर बार स्टैक के दूसरे-से-शीर्ष तत्व को बढ़ाते हैं, फिर शीर्ष को 2 से विभाजित करते हैं।

— histocrat
स्रोत

3

रेटिना ,29 17

+`\b(1+)\1$
;$1
;

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

2 बाइट्स ने मार्टिन को धन्यवाद दिया!

अनुपयोगी इनपुट लेता है। यह बार-बार 1s की सबसे बड़ी मात्रा से मेल खाता है, यह ऐसा हो सकता है कि 1s की संख्या, संख्या के बाकी हिस्सों से बिल्कुल मेल खाती है 1। हर बार जब यह ऐसा होता है तो यह ;स्ट्रिंग के लिए प्रस्तुत करता है। अंत में, हम ;स्ट्रिंग में s की संख्या गिनते हैं ।

यदि आप दशमलव इनपुट चाहते हैं, तो जोड़ें:

\d+
$0$*1

कार्यक्रम की शुरुआत के लिए।

— FryAmTheEggman
स्रोत

3

जोल्फ, 6 बाइट्स

यहाँ कोशिश करो!

Zlm)j2
Zl   2  count the number occurrences of 2 in
  m)j   the prime factorization of j (input)

बल्कि सरल ... योस को जुला को बाहर निकालने के लिए यूडप्रोडक्शन के लिए कुडोस जो कि वास्तव में काम करना चाहिए!

— कोनोर ओ ब्रायन
स्रोत

1

इस चुनौती के लिए 6 बाइट्स जादू की संख्या लगती है

— साइको

3

PARI / GP, 17 बाइट्स

n->valuation(n,2)

— चार्ल्स
स्रोत

3

6502 मशीन भाषा, 7 बाइट्स

संचायक में परिणाम को छोड़कर, संचायक में नॉनजरू मान के कम से कम 1 महत्वपूर्ण स्थान का पता लगाने के लिए:

A2 FF E8 4A 90 FC 60

पर इस चलाने के लिए e-tradition.net पर 6502 सिम्युलेटर , अवश्य लगा दें A9एक 8 बिट पूर्णांक द्वारा पीछा किया।

यह निम्नलिखित को दर्शाता है:

count_trailing_zeroes:
    ldx #$FF
loop:
    inx
    lsr a     ; set carry to 0 iff A divisible by 2, then divide by 2 rounding down
    bcc loop  ; keep looping if A was divisible by 2
    rts       ; return with result in X

यह निम्न C के बराबर है, सिवाय इसके कि C को intकम से कम 16-बिट होना चाहिए :

unsigned int count_trailing_zeroes(int signed_a) {
    unsigned int carry;
    unsigned int a = signed_a;  // cast to unsigned makes shift well-defined
    unsigned int x = UINT_MAX;
    do {
        x += 1;
        carry = a & 1;
        a >>= 1;
    } while (carry == 0);
    return x;
}

एमएक्स = 01 (16-बिट संचायक, 8-बिट इंडेक्स) मानकर 65816 पर समान काम करता है, और उपरोक्त सी स्निपेट के बराबर है।

— डेमियन येरिक
स्रोत

2

ब्रेकीलॉग , 27 15 बाइट्स

$pA:2xlL,Al-L=.

व्याख्या

$pA             § Unify A with the list of prime factors of the input
   :2x          § Remove all occurences of 2 in A
      lL,       § L is the length of A minus all the 2s
         Al-L=. § Unify the output with the length of A minus L

— Fatalize
स्रोत

2

सीजेएम, 8 बाइट्स

rizmf2e=

पूर्णांक, निरपेक्ष मान, अभाज्य गुणनखण्ड, गणना दोहों को पढ़ें।

— लिन
स्रोत

2

जावास्क्रिप्ट ईएस 6, 36 38 बाइट्स

@ETHproductions के लिए धन्यवाद दो बाइट्स गोल्फ

बहुत उबाऊ जवाब है, लेकिन यह काम करता है। मई वास्तव में एक अन्य उत्तर के समान है, यदि वह सुझाए गए परिवर्तनों को जोड़ता है तो मैं उसे हटा दूंगा।

b=>{for(c=0;b%2-1;c++)b/=2;alert(c)}

इसे चलाने के लिए, इसे एक चर ( a=>{for...) के रूप में असाइन करें क्योंकि यह एक अनाम फ़ंक्शन है, फिर इसे कॉल करें a(100)।

— कॉनर बेल
स्रोत

अच्छा जवाब! b%2==0को बदला जा सकता है b%2-1, और बयान c++के अंतिम भाग के अंदर ले जाया जा सकता है for। मुझे लगता है कि यह भी काम करेगा:b=>eval("for(c=0;b%2-1;b/=2)++c")

— ETHproductions

@ETHproductions तो यह कर सकते हैं! अच्छी पकड़ :)

— कॉनर बेल

एक और बाइट: b%2-1=> ~b&1इसके अलावा, मुझे लगता है कि यह इनपुट पर विफल रहता है 0, जिसके साथ तय किया जा सकता हैb&&~b&1

— ETHproductions

एक नकारात्मक संख्या पर मेरे कंप्यूटर का परीक्षण फ्रॉज़ करें। b%2-1ऋणात्मक विषम संख्याओं के लिए जाँच विफल हो जाती है।

— पैट्रिक रॉबर्ट्स

2

ईएस 6, 22 बाइट्स

n=>31-Math.clz32(n&-n)

यदि आप 0 पास करते हैं तो रिटर्न -1 आता है।

— नील
स्रोत

बहुत सुंदर। मैं clz32 के बारे में भूल गया: पी

— कॉनर ओ'ब्रायन

2

डीयूपी , 20 बाइट्स

[$2/%0=[2/f;!1+.][0]?]f:

Try it here!

रिकर्सन में परिवर्तित, आउटपुट अब स्टैक पर शीर्ष नंबर है। उपयोग:

94208[2/\0=[f;!1+][0]?]f:f;!

व्याख्या

[                ]f: {save lambda to f}
 2/\0=               {top of stack /2, check if remainder is 0}
      [     ][ ]?    {conditional}
       f;!1+         {if so, then do f(top of stack)+1}
              0      {otherwise, push 0}

— मामा फन रोल
स्रोत

2

जाप, ९ ५ बाइट्स

¢w b1

इसे ऑनलाइन टेस्ट करें!

पिछले संस्करण में पांच बाइट्स होने चाहिए थे, लेकिन यह वास्तव में काम करता है।

यह काम किस प्रकार करता है

       // Implicit: U = input integer
¢      // Take the binary representation of U.
w      // Reverse.
b1     // Find the first index of a "1" in this string.
       // Implicit output

— ETHproductions
स्रोत

2

सी, 44 40 38 36 बाइट्स

धन्यवाद @JohnWHSmith से 2 बाइट्स । 2 बाइट्स बंद धन्यवाद @luserdroog ।

a;f(n){for(;~n&1;n/=2)a++;return a;}

आइडोन पर टेस्ट लाइव ।

— हटा दिया
स्रोत

आप !(n%2)एक छोटे से एक के साथ महंगा की जगह 1 बाइट लेने में सक्षम हो सकता है ~n&1।

— जॉन डब्ल्यूएच स्मिथ

@JohnWHSmith। वह अच्छा था!! धन्यवाद

— हटा दिया

निकालें =0।

— ग्लोबल्स को अनुमानित

@luserdroog। धन्यवाद, मुझे इसके बारे में पता नहीं था।

— हटा दिया

सही है अगर मैं गलत हूं, लेकिन चूंकि यह फ़ंक्शन वैश्विक चर का उपयोग करता है a, तो क्या यह केवल पहली बार काम करने की गारंटी नहीं है? मुझे नहीं पता था कि अनुमति दी गई थी।

— पैट्रिक रॉबर्ट्स

एक संख्या भी कैसे है?

जेली , 4 बाइट्स

x86_64 मशीन कोड, 4 बाइट्स

निर्देश:

पायथन, 25 बाइट्स

अजगर, 6 बाइट्स

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

जावास्क्रिप्ट ईएस 6, 22 19 बाइट्स

पायथ, 8 बाइट्स

05AB1E , 4 5 बाइट्स

अजगर, 6 बाइट्स

MATL , 5 बाइट्स

सी, 36 (28) बाइट्स

जावा 7, 39 या शायद 44 बाइट्स

जावास्क्रिप्ट (ईएस 6), 20 बाइट्स 19 बाइट्स।

पर्ल 6, 23 18 बाइट्स

रूबी 24 बाइट्स

जे, 6 बाइट्स

सी, 37 बाइट्स

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

बेफुज, २०

रेटिना ,29 17

जोल्फ, 6 बाइट्स

PARI / GP, 17 बाइट्स

6502 मशीन भाषा, 7 बाइट्स

ब्रेकीलॉग , 27 15 बाइट्स

व्याख्या

सीजेएम, 8 बाइट्स

जावास्क्रिप्ट ईएस 6, 36 38 बाइट्स

ईएस 6, 22 बाइट्स

डीयूपी , 20 बाइट्स

व्याख्या

जाप, ९ ५ बाइट्स

यह काम किस प्रकार करता है

सी, 44 40 38 36 बाइट्स