पूर्णांक के बाइनरी मान में 1 की सबसे लंबी श्रृंखला की गणना करें

32

लक्ष्य

एक गैर-नकारात्मक पूर्णांक को देखते हुए, एक ऐसा फ़ंक्शन बनाएं जो उस पूर्णांक के बाइनरी मान में सबसे बड़ी लगातार 1 की संख्या की प्रारंभिक स्थिति लौटाता है।

जब एक इनपुट दिया जाता है 0, तो वापस लौटें 0।

यदि संख्या में समान लंबाई के कई धारियाँ हैं, तो आपको अंतिम लकीर की स्थिति को वापस करना होगा।

इनपुट

एक पूर्णांक 0 से अधिक या बराबर ।

उत्पादन

एक पूर्णांक की गणना नीचे बताई गई है।

नियम

  • यह कोड-गोल्फ है, इसलिए प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीत जाता है।
  • मानक खामियों को मना किया जाता है।

उदाहरण और परीक्षण मामले

उदाहरण 1

  • आपका फ़ंक्शन पूर्णांक 142 से पारित हुआ है
  • 142 बाइनरी में 10001110 के बराबर है
  • सबसे लंबी लकीर है "111" (तीन लोगों की एक लकीर)
  • लकीर 2 ^ 1 की स्थिति में शुरू होती है
  • आपका फ़ंक्शन परिणाम के रूप में 1 देता है

उदाहरण 2

  • आपका फ़ंक्शन पूर्णांक 48 पास है
  • बाइनरी में 48 110000 के बराबर है
  • सबसे लंबी लकीर है "11" (दो लोगों की एक लकीर)
  • लकीर 2 ^ 4 की स्थिति में शुरू होती है
  • आपका फ़ंक्शन परिणाम के रूप में 4 देता है

उदाहरण 3

  • आपका फ़ंक्शन पूर्णांक 750 पास है
  • 750 बाइनरी में 1011101110 के बराबर है
  • सबसे लंबी लकीर है "111" (तीन लोगों की एक लकीर)
  • चूंकि समान लंबाई की दो लकीरें होती हैं, हम बाद की लकीर को लौटा देते हैं।
  • बाद की लकीर 2 ^ 5 की स्थिति में शुरू होती है
  • आपका फ़ंक्शन परिणाम के रूप में 5 देता है
code-golf  binary  bitwise 
— वास्तव में
स्रोत
1
आपको एक जीत मानदंड की आवश्यकता है, जैसे
— ओएक्सएक्स
@ ओएक्सएक्स का उल्लेख शरीर में ही किया गया था इसलिए मैंने टैग जोड़ा।
— पूरी तरह से
सुनिश्चित करें कि लोग परीक्षण करें 0। यह एक महत्वपूर्ण परीक्षण मामला है।
— mbomb007
2
"अंतिम लकीर" या "नवीनतम लकीर" के बजाय, मैं "सबसे बड़ी जगह मूल्य के साथ लकीर" का सुझाव दूंगा।
— aschepler
@ ओकेएक्स क्यों एक जीत मानदंड आवश्यक है? यह केवल एक पहेली क्यों नहीं हो सकता?
— corsiKa

जवाबों:

21

जेली , 10 8 बाइट्स

Ba\ÐƤṀċ¬

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

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

Ba\ÐƤṀċ¬  Main link. Argument: n


B         Binary; convert n to base 2.

   ÐƤ     Apply the link to the left to all postfixes of the binary array.
 a\         Cumulatively reduce by logical AND.

          For example, the array

          [1, 0, 1, 1, 1, 0, 1, 1, 1, 0]

          becomes the following array of arrays.

          [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
             [0, 0, 0, 0, 0, 0, 0, 0, 0]
                [1, 1, 1, 0, 0, 0, 0, 0]
                   [1, 1, 0, 0, 0, 0, 0]
                      [1, 0, 0, 0, 0, 0]
                         [0, 0, 0, 0, 0]
                            [1, 1, 1, 0]
                               [1, 1, 0]
                                  [1, 0]
                                     [0]

     Ṁ    Take the lexicographical maximum, i.e., the array with the most 1's at
          the beginning, breaking ties by length.

       ¬  Yield the logical NOT of n, i.e., 0 if n > 0 and 1 if n = 0.

      ċ   Count the occurrences of the result to the right in the one to the left.
— डेनिस
स्रोत
बधाई हो!
— वास्तविक
24

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

सहेजे गए 4 बाइट्स @ThePirateBay की बदौलत

f=x=>(k=x&x/2)?f(k):Math.log2(x)|0

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

कोड स्निपेट दिखाएं

कैसे?

सामान्य मामला x> 0

हम पुनरावृत्ति और x / 2 के साथ इनपुट x जो क्रमिक सेट बिट्स के पैटर्न को उत्तरोत्तर कम करते हैं जब तक कि अनुक्रम का केवल सबसे सही बिट रहता है। हम अंतिम गैर-शून्य मान की एक प्रति रखते हैं और इसके आधार -2 लॉगरिदम को फर्श पर गोल करके इसके सबसे महत्वपूर्ण बिट की स्थिति निर्धारित करते हैं।

नीचे हम x = 750 ( बाइनरी में 1011101110 ) के लिए जाने वाले चरण हैं ।

    1011101110 --.
,----------------'
'-> 1011101110
AND 0101110111
    ----------
=   0001100110 --.
,----------------'
'-> 0001100110
AND 0000110011
    ----------
=   0000100010 --.  --> output = position of MSB = 5  (0000100010)
,----------------'                                         ^
'-> 0000100010
AND 0000010001
    ----------
=   0000000000

बढ़त मामला x = 0

विशेष मामला x = 0तुरंत होता है Math.log2(0) | 0। द्विआधारी बिटवाइज के 0मूल्यांकन का लघुगणक -Infinityया 32-बिट पूर्णांक के लिए एक बल बनाता है। अमूर्त ऑपरेशन ToInt32 के विनिर्देश के अनुपालन में , यह अपेक्षित है 0:

अगर संख्या है NaN , +0 , -0 , + ∞ , या -∞ , लौट +0

— Arnauld
स्रोत
इनपुट के लिए यह त्रुटियां 0, जो इनपुट रेंज का हिस्सा है।
— जस्टिन मैरिनर
@JustinMariner फिक्स्ड।
— अरनुलद
Math.log2(k)|0इसके बजाय क्या 31-Math.clz32(k)? या क्या मैं कुछ न कुछ भूल रहा हूं?
@PirateBay Math.log2(k)|0वास्तव में विशेष मामले के लिए कम और सरल दोनों है x=0। धन्यवाद। :)
— अरनुलद
1
बहुत अच्छा एल्गोरिथ्म, और अच्छी व्याख्या। मैंने इसे x86 मशीन कोड के 14 बाइट्स में लागू किया ।
— पीटर कॉर्ड्स
12

x86 मशीन कोड, 14 बाइट्स

@ Arnauld के एल्गोरिथ्म का उपयोग करना x &= x>>1और xबनने से पहले चरण में उच्चतम सेट बिट स्थिति लेना 0।

X86-64 unsigned longest_set(unsigned edi);सिस्टम V ABI में हस्ताक्षर के साथ C / C ++ से कॉल करने योग्य। समान मशीन-कोड बाइट्स 32-बिट मोड में उसी तरह से डिकोड होंगे, लेकिन मानक 32-बिट कॉलिंग कन्वेंशन पहले arg को नहीं डालते हैं edi। (इनपुट रजिस्टर को ecxया edxविंडोज के लिए बदलना _fastcall/ _vectorcallया gcc -mregparmबिना कुछ तोड़े किया जा सकता है।)

   address   machine-code
             bytes
                         global longest_set
 1                       longest_set:
 2 00000000 31C0             xor  eax, eax    ; 0 for input = 0
 3                       
 4                       .loop:               ; do{
 5 00000002 0FBDC7           bsr  eax, edi    ;  eax = position of highest set bit
 6                           ;; bsr leaves output unmodified when input = 0 (and sets ZF)
 7                           ;; AMD documents this; Intel manuals say unspecified but Intel CPUs implement it
 8 00000005 89F9             mov  ecx, edi
 9 00000007 D1E9             shr  ecx, 1
10 00000009 21CF             and  edi, ecx
11 0000000B 75F5             jnz .loop        ; } while (x &= x>>1);
12                       
13 0000000D C3               ret

x86 का BSRनिर्देश (बिट स्कैन रिवर्स) इसके लिए एकदम सही है, जो हमें अग्रणी शून्य की गिनती करने के बजाय सीधे बिट-इंडेक्स देता है। ( bsrइनपुट के लिए सीधे 0 का उत्पादन नहीं करता है = जैसे चाहें 32-lzcnt(x), लेकिन हमें गैर-शून्य इनपुट के लिए bsr = 31-lzcnt की आवश्यकता होती है, इसलिए lzcntनिर्देश भी नहीं बचाएंगे, अकेले बाइट को गिनने दें। लूप के काम करने से पहले शून्य को फिर से भरना । bsr' इनपुट शून्य होने पर गंतव्य को अनधिकृत रूप से छोड़ने का अर्ध-आधिकारिक व्यवहार।)

यह और भी छोटा होगा यदि हम सबसे लंबे समय तक चलने वाले MSB पद को वापस कर सकते हैं। उस मामले में, lea ecx, [rdi+rdi](3 बाइट्स) + नक़ल की बाईं के बजाय -Shift mov+ shr(4 बाइट्स)।

इस asio कॉलर के लिए यह TIO लिंक देखेंexit(longest_set(argc-1));

एक शेल लूप के साथ परीक्षण:

l=(); for ((i=0;i<1025;i++));do 
    ./longest-set-bitrun "${l[@]}";   # number of args = $i
    printf "$i %#x: $?\n" $i; 
    l+=($i); 
done | m

0 0: 0
1 0x1: 0
2 0x2: 1
3 0x3: 0
4 0x4: 2
5 0x5: 2
6 0x6: 1
7 0x7: 0
8 0x8: 3
9 0x9: 3
10 0xa: 3
11 0xb: 0
12 0xc: 2
13 0xd: 2
14 0xe: 1
15 0xf: 0
16 0x10: 4
17 0x11: 4
18 0x12: 4
19 0x13: 0
20 0x14: 4
21 0x15: 4

...

747 0x2eb: 5
748 0x2ec: 5
749 0x2ed: 5
750 0x2ee: 5
751 0x2ef: 0
752 0x2f0: 4
753 0x2f1: 4
754 0x2f2: 4
— पीटर कॉर्डेस
स्रोत
1
अच्छा! उन लोगों के लिए एक नोट जो (मेरे जैसे) अन्य विधानसभा बोलियों से अधिक परिचित हैं: x86 बीएसआर mnemonic "बिट स्कैन रिवर्स" के लिए खड़ा है, न कि "ब्रांच टू सबरूटीन"।
— अरनौलद
@ अर्नुलड: अच्छा बिंदु, मेम्नेनिक को डीकोड करने के लिए संपादित किया गया है और साथ ही साथ इंस संदर्भ मैनुअल प्रविष्टि के लिए एक लिंक है।
— पीटर कॉर्ड्स
5

जेली , 19 17 11 बाइट्स

HÐĿ&\ḟ0ṪBL’

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

-6 (!) @ डेनिस की गहरी टिप्पणियों के लिए धन्यवाद बाइट्स

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

HÐĿ&\ḟ0ṪBL’
HÐĿ         - halve repeatedly until reaching 0 due to rounding
   &\       - cumulative AND
     ḟ0Ṫ    - final non-zero, or 0 if all elements are 0
        BL  - length of binary representation (log base 2). 0->[0]->1
          ’ - decrement
— fireflame241
स्रोत
के लिए त्रुटियां 0, जो इनपुट रेंज में है।
— श्री एक्सकोडर
@ Mr.Xcoder फिक्स्ड
— फायरफ्लेम 241 21
आप फिक्स के लिए एक बाइट बचा सकते हैंȯ-µ...
— जोनाथन एलन
@JonathanAllan मुझे समझ नहीं आ रहा है कि OR-ing कैसे मदद करेगा। क्या आपके पास कोड है?
— फायरफ्लेम 241 21
1
चूंकि Bहमेशा एक सरणी देता है जो 1 से शुरू होता है , BUṪMṪ’×Ṡबन सकता है ṪBL’। इसके अलावा, आप की जरूरत नहीं है Ḟ, और ḟ0एक बाइट बचाता है ¹Ðf।
— डेनिस
5

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

f=lambda x:f(x&x/2)if x&x/2else len(bin(x))-3

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

डेनिस के लिए बहुत धन्यवाद बाइट्स सहेजे गए! (इसके len(bin(...))-3बजाय सिर ऊपर math.frexp)

बग ढूंढने के लिए @xnor को धन्यवाद, जो सौभाग्य से आसानी से ठीक हो गया था!

— मिस्टर एक्सकोडर
स्रोत
यह गलत उत्तर देने के लिए लगता है जैसे कि x=3, मुझे लगता है कि and/orशॉर्ट-सर्किट गलत होने के कारण जब फंक्शन वापस आता है
— xnor
@xnor ध्यान देने वाली बात के लिए धन्यवाद! यह तय हो चुका है।
— मिस्टर एक्सकोडर
4

पर्ल 6 ,45 35 बाइट्स

यह अत्यधिक उन्नत संस्करण @nwellnhof के सौजन्य से है।

{.msb+1-(.base(2)~~m:g/1+/).max.to}

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

— Ramillies
स्रोत
आप बस :gसभी मैच प्राप्त करने के लिए मैच कर सकते हैं । स्मार्ट-मैच ऑपरेटर के साथ, मैं इसे 40 बाइट तक नीचे गिरा सकता था:{sort(.base(2).flip~~m:g/1+/).tail.from}
— nwellnhof
और 35 बाइट्स के लिए:{.msb+1-(.base(2)~~m:g/1+/).max.to}
— nwellnhof
@nwellnhof, आपका बहुत-बहुत धन्यवाद। मैं किसी तरह चूक गया :gऔर समझ नहीं पाया कि मैं स्मार्टमैच ऑपरेटर के साथ क्रिया विशेषण का उपयोग कैसे कर सकता हूं। साथ ही यह .msbविधि यहां काफी सहायक है और मुझे इसके बारे में पहले नहीं पता था।
— रामलीज
3

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

m=t=i=j=0
for c in bin(input()):
 t=-~t*(c>'0');i+=1
 if t>m:j=i;m=t
print i-j

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

संपादित करें: श्री एक्सकोडर के लिए 11 बाइट्स का धन्यवाद।

— चास ब्राउन
स्रोत
— श्री एक्सकोडर
— श्री एक्सकोडर
@ Mr.Xcoder मैंने भी इसके बारे में सोचा, हालांकि सवाल विशेष रूप से एक फ़ंक्शन लिखने के लिए कहता है।
— जोनाथन फ्रीच
@JonathanFrech मुझे नहीं लगता कि ओपी वास्तव में कार्य करता है । शायद सिर्फ एक सामान्य शब्द है।
— श्री एक्सकोडर
@ Mr.Xcoder कृपया इसे समझाएं। धन्यवाद,
— लाइफबैलेंस
3

05AB1E , 14 12 11 बाइट्स

bDγàŠrkrJgα

इसे ऑनलाइन आज़माएं! या परीक्षण मामले चलाते हैं ।

व्याख्या

bDγàŠrkrJgα  Implicit input (ex: 750)
bD           Convert input to binary string and duplicate
                 '1011101110', '1011101110'
  γ          Split into groups of 1s or 0s
                 '1011101110', ['1', '0', '111', '0', '111', '0']
   à         Pull out max, parsing each as an integer
                 '1011101110', ['1', '0', '0', '111', '0'], '111'
    Šrk      Rearrange stack and get first index of max run of ones
                 ['1', '0', '0', '111', '0'], 2
       rJg   Reverse stack, join the array to a string, and get its length
                 2, 7
          α  Get absolute difference
                 5
— जस्टिन मेरिनर
स्रोत
3

जे , 18 17 बाइट्स

(#-0{#\\:#.~\)@#:

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

व्याख्या

(#-0{#\\:#.~\)@#:  Input: integer n
               #:  Binary
     #\            Length of each prefix
       \:          Sorted down using
         #.~\      Mixed base conversion on each prefix
   0{              Get the value at index 0
  -                Subtract from
 #                 Length
— मील की दूरी पर
स्रोत
बहुत चालाक है। सुनिश्चित नहीं हैं कि मैं पूरी तरह से समझता हूं कि मिश्रित आधार रूपांतरण के साथ क्या हो रहा है। यह स्ट्रिंग के अंत में लगातार लोगों की संख्या की गणना क्यों करता है? इसके अलावा, अगर xडाईड पर निर्दिष्ट आधार सभी 0 और 1 हैं, तो इसका क्या मतलब है? आधार 2 संख्या में अंक होते हैं 0और 1इसलिए आधार 1संख्या में अंक होते हैं ... 0? फिर 1उस संदर्भ में क्या मतलब है? और क्या आधार 0नंबर हमेशा ही होता है 0?
— जोनाह
@ जोहा यह मिश्रित आधार रूपांतरण लागू होने के कारण अधिक है। x #. yपहले गणना w =: */\. }. x , 1फिर रिटर्न+/ w * y
— मील
तो क्या आप इसे #.सार्वजनिक उपयोग के बजाय आंतरिक कार्यान्वयन विवरणों पर निर्भर होने के बजाय, एक वैध उपयोग के बजाय एक गोल्फ हैक मानेंगे?
— जोनाह
3

सी # (.NET कोर) , 64 60 बाइट्स

T=a=>(a&a/2)>0?T(a&a/2):Math.Log(a,2)<0?0:(int)Math.Log(a,2)

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

@ अरनुलद के उत्तर का एसी # संस्करण

स्वीकृतियाँ

केविन क्रूज़सेन की बदौलत 4 बाइट बच गए।

सी # (.NET कोर) , 131 123 + 18 = 141 बाइट्स

a=>{string s=Convert.ToString(a,2),t=s.Split('0').OrderBy(x=>x.Length).Last();return a<1?0:s.Length-s.IndexOf(t)-t.Length;}

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

+18 बाइट्स के लिए using System.Linq;

स्वीकृतियाँ

8 बाइट्स ने ग्रेज़गोरज़ पुलावस्की के लिए धन्यवाद बचाया।

Degolfed

a=>{
    string s=Convert.ToString(a,2),      // Convert to binary
    t=s.Split('0')                       // get largest group of 1's
       .OrderBy(x=>x.Length)
       .Last();
    return 
        a<1?0:                          // handle 0 case
        s.Length-s.IndexOf(t)-t.Length; // get position in reversed string
}

सी # (.NET कोर) , 164 161 बाइट्स

a=>{var s=Convert.ToString(a,2);int c=0,l=0,p=0,k=0,j=s.Length-1,i=j;for(;i>=0;i--){if(s[i]>'0'){if(i==j||s[i+1]<'1'){p=i;c=0;}if(++c>=l){l=c;k=p;}}}return j-k;}

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

एक गैरLinq समाधान, जो मुझे यकीन है कि सुधार किया जा सकता है, हालांकि कुछ भी तुरंत स्पष्ट नहीं है।

Degolfed

a=>{
    var s=Convert.ToString(a,2); // Convert to binary
    int c=0,l=0,p=0,k=0,j=s.Length-1,i=j;
    for(;i>=0;i--)               // Loop from end of string
    {
        if(s[i]>'0')             // if '1'
        {
            if(i==j||s[i+1]<'1') // if first digit or previous digit was '0'
            {
                p=i;             // set the position of the current group
                c=0;             // reset the count
            }
            if(++c>=l)           // if count is equal or greater than current largest count
            {
                l=c;             // update largest count
                k=p;             // store position for this group
            }
        }
    }
    return j-k;                  // as the string is reversed, return string length minus position of largest group
}
— Ayb4btu
स्रोत
1
आप rपहले उत्तर में खाई द्वारा 8 बाइट बचा सकते हैं : tio.run/##dY9RS8MwFIWfza/…
— Grzegorz Puławski
आप के अपने बंदरगाह में दो बाइट्स बचा सकता है Arnauld 'इस तरह है:T=a=>{int x=(int)Math.Log(a,2);return(a&=a/2)>0?T(a):x<0?0:x;}
— केविन Cruijssen
1
या फिर दो और बाइट्स बचाए गए ( 60 बाइट्स ):T=a=>(a&a/2)>0?T(a&a/2):Math.Log(a,2)<0?0:(int)Math.Log(a,2)
— केविन क्रूज़सेन 19'17
2

भूसी , 12 बाइट्स

→S§-€¤≠Lo▲gḋ

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

व्याख्या

                 Implicit input, e.g                           750
           ḋ     Convert to binary                             [1,0,1,1,1,0,1,1,1,0]
          g      Group equal elements                          [[1],[0],[1,1,1],[0],[1,1,1],[0]]
        o▲       Maximum                                       [1,1,1]
    €            Index of that substring in the binary number  3
     ¤≠L         Absolute difference of lengths                abs (3 - 10) = 7
 S§-             Subtract the two                              7 - 3 = 4
→                Increment                                     5
— H.PWiz
स्रोत
2

जेली ,  14 13 12  11 बाइट्स

Bµṣ0Ṫ$ƤMḢạL

एक ऋणात्मक लिंक जो गैर-नकारात्मक पूर्णांकों को ले रहा है और वापस कर रहा है।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

Bµṣ0Ṫ$ƤMḢạL - Main link: number, n                   e.g. 750
B           - convert to a binary list                    [1,0,1,1,1,0,1,1,1,0]
 µ          - monadic chain separation, call that b
      Ƥ     - map over prefixes:  (i.e. for [1], [1,0], [1,0,1], [1,0,1,1],...)
     $      -   last two links as a monad:                e.g.: [1,0,1,1,1,0,1,1]
   0        -     literal zero                                   0
  ṣ         -     split (prefix) at occurrences of (0)           [[1],[1,1,1],[1,1]]
    Ṫ       -     tail                                                        [1,1]
       M    - maximal indices                             [5,9]
        Ḣ   - head                                        5
          L - length (of b)                               10
         ạ  - absolute difference                         5
— जोनाथन एलन
स्रोत
मेरे पास एक समान समाधान था लेकिन ŒrṪPइसके बजाय उपसर्गों पर उपयोग किया गया।
— मील
2

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

BŒgḄṀB
BwÇɓÇL+ɓBL_‘

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

 4  को बचाने के लिए जोनाथन एलन को धन्यवाद 6 बाइट !

मैंने इसे छोड़ने के लिए बहुत अधिक काम किया है, हालांकि यह लंबे समय तक है। मैं वास्तव में एक समाधान जोड़ना चाहता था जो कि 1द्विआधारी प्रतिनिधित्व में सबसे लंबे विकल्प के लिए सचमुच खोजता है ...

व्याख्या

Bg .B - मोनाडिक हेल्पर लिंक। अगली कड़ी में be के साथ उपयोग किया जाएगा।

बी - बाइनरी प्रतिनिधित्व।
 Œg - समूह लगातार समान तत्वों के चलाता है।
   Binary - बाइनरी से पूर्णांक में परिवर्तित करें।
    Value - अधिकतम मूल्य।
     बी - पूर्णांक से बाइनरी में कनवर्ट करें।


Bw BL + ɓBL_ '- मुख्य लिंक।

बी - बाइनरी प्रतिनिधित्व (इनपुट का)।
  As - एक सनद के रूप में अंतिम कड़ी। इनपुट पूर्णांक लेता है।
 w - पहला सबलिस्ट इंडेक्स।
   separate - एक अलग रंग श्रृंखला शुरू करें। तर्कों को उलट देता है।
    As - एक सनद के रूप में अंतिम कड़ी।
     एल - लंबाई।
      + - जोड़
       separate - एक अलग रंग श्रृंखला शुरू करें। तर्कों को उलट देता है।
        ब - बाइनरी।
         एल - लंबाई।
          _ '- परिणाम घटाना और बढ़ाना (क्योंकि जेली 1-इंडेक्सिंग का उपयोग करता है)।
              - अवैध रूप से उत्पादन।
— मिस्टर एक्सकोडर
स्रोत
BŒgḄṀBइसके बजाय आपका सहायक लिंक हो सकता है
— जोनाथन एलन
@JonathanAllan ओह वाह धन्यवाद!
— श्री एक्सकोडर
आपका मुख्य लिंक हो सकता हैBwÇɓÇL+ɓBL_‘
— जोनाथन एलन
@JonathanAllan वाह, फिर से धन्यवाद!
— मिस्टर एक्सकोडर
2

कोटलिन , 77 बाइट्स

{val b=it.toString(2)
b.reversed().lastIndexOf(b.split(Regex("0+")).max()!!)}

सजा हुआ

{
    val b = it.toString(2)
    // Find the left position of the first instance of
    b.reversed().lastIndexOf(
            // The largest group of 1s
            b.split(Regex("0+")).max()!!)
}

परीक्षा

var s:(Int)->Int =
{val b=it.toString(2)
b.reversed().lastIndexOf(b.split(Regex("0+")).max()!!)}
fun main(args: Array<String>) {
    r(0, 0)
    r(142, 1)
    r(48, 4)
    r(750, 5)
}

fun r(i: Int, i1: Int) {
    var v = s(i)
    println("$i -> $v [$i1] ${i1 == v}")
}
— jrtapsell
स्रोत
मैंने परीक्षण नहीं किया लेकिन लगता है कि यह स्कैला में भी काम करता है।
— वी। कोर्टोइस
2

हास्केल , 101 98 96 75 बाइट्स

snd.maximum.(`zip`[0..]).c
c 0=[0]
c n|r<-c$div n 2=sum[r!!0+1|mod n 2>0]:r

इसे ऑनलाइन आज़माएं!उपयोग: snd.maximum.(`zip`[0..]).c $ 142पैदावार 1।

स्पष्टीकरण:

  • cइनपुट को बाइनरी में परिवर्तित करता है, जबकि एक ही समय में एक की लकीरों की लंबाई की गिनती करता है, एक सूची में परिणाम एकत्र करता है। r<-c$div n 2पुनरावर्ती रूप से शेष की गणना करता हैrइस सूची की , जबकि sum[r!!0+1|mod n 2>0]:rलकीर की वर्तमान लंबाई को जोड़ता है r। सूची समझने की जाँच करता mod n 2>0है कि क्या, वर्तमान बाइनरी अंक एक है, और यदि ऐसा है, तो पिछली लकीर (पहले तत्व r) की लंबाई लेता है और एक जोड़ता है। अन्यथा सूची बोध रिक्त है, और sum[]पैदावार 0। उदाहरण इनपुट के लिए, c 142सूची की पैदावार करें [0,3,2,1,0,0,0,1,0]।

  • (`zip`[0..])टपल के दूसरे घटक के रूप में पिछली सूची के प्रत्येक तत्व में स्थिति जोड़ता है। उदाहरण के लिए यह देता है [(0,0),(3,1),(2,2),(1,3),(0,4),(0,5),(0,6),(1,7),(0,8)]।

  • maximumइस सूची में लेक्सिकोग्राफिक रूप से अधिकतम टपल पाया जाता है, जो कि लकीर की लंबाई पहले माना जाता है क्योंकि वे पहले घटक होते हैं, और दूसरे घटक को बाँधने की स्थिति में, अर्थात् बड़ा सूचकांक, निर्णय लेता है। यह प्रदान करता है(3,1) उदाहरण मेंsnd देता है , और टपल का दूसरा घटक देता है।

— Laikoni
स्रोत
2

सी (जीसीसी) , 81 80 बाइट्स

i,l,c,r;f(n){for(i=l=c=r=0;n;n/=2,i++)c=n&1?c+1:c>=l?r=i-(l=c),0:0;n=c<l?r:i-c;}

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

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

@ अरनौलद के जवाब का एसी संस्करण

k;f(n){n=(k=n&n/2)?f(k):(k=log2(n))<0?0:k;}

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

— cleblanc
स्रोत
मिस एन वापसी; या वापसी k; कथन
— RosLuP
के n<1?0:log2(n)बजाय सुझाव(k=log2(n))<0?0:k
— छत 14
2

MS SQL सर्वर, 437 426 407 398 बाइट्स

एसक्यूएल फिडल

मुझे यकीन है कि मैं लाइन ब्रेक आदि को हटा सकता था, लेकिन यह उतना ही कॉम्पैक्ट है जितना मैं इसे बनाने के लिए तैयार था: 

create function j(@ int)
returns int
as BEGIN
declare @a varchar(max)='',@b int,@c int=0,@d int=0,@e int=0,@f int=0,@g int=0,@h int=0
while @>0 BEGIN SELECT @a=cast(@%2 as char(1))+@a,@=@/2
END
SET @b=len(@a)
while @<@b
BEGIN
select @c=@d,@d=cast(substring(@a,@b-@,1)as int)
IF @d=1
BEGIN IF @c=0
SELECT @e=@,@g=1
else SET @g+=1 END
IF @g>=@h BEGIN select @h=@g,@f=@e END
SET @+=1
END
return @f
END

यहाँ एक और अधिक पठनीय संस्करण है: 

create function BinaryString(@id int)
returns int
as BEGIN
  declare @bin varchar(max)
  declare @binLen int
  declare @pVal int = 0
  declare @Val int = 0
  declare @stC int = 0 --start of current string of 1s
  declare @stB int = 0 --start of biggest string of 1s
  declare @lenC int = 0 --length of current string of 1s
  declare @lenB int = 0 --length of biggest string of 1s

  set @bin = ''

    while @id>0
      BEGIN
        SET @bin = cast(@id%2 as varchar(1)) + @bin
        SET @id = @id/2
      END

    SET @binLen = len(@bin)

    while @id<@binLen
      BEGIN
        set @pVal = @Val
        set @Val = cast(substring(@bin,@binLen-@id,1) as int)
        IF @Val = 1 and @pVal = 0
          BEGIN 
            SET @stC = @id
            SET @lenC = 1
          END
        IF @Val = 1 and @pVal = 1
          BEGIN 
            SET @lenC = @lenC + 1
          END
        IF @lenC >= @lenB
          BEGIN
            set @lenB = @lenC
            set @StB = @StC
          END

        SET @id = @id + 1 
      END

  return @StB
END

वास्तविक चाल यह है कि जहां तक ​​मुझे पता चला है, दशमलव से बाइनरी में एक संख्या को बदलने के लिए कोई मूल SQL कार्यक्षमता नहीं है। नतीजतन, मुझे रूपांतरण को मैन्युअल रूप से बाइनरी में कोड करना पड़ा, फिर मैं एक स्ट्रिंग, एक चरित्र के रूप में एक समय में जब तक मुझे सही संख्या नहीं मिली, मैं तुलना कर सकता था।

मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका है, लेकिन मैंने एक (एन) एसक्यूएल जवाब नहीं देखा, इसलिए मुझे लगा कि मैं इसे वहां फेंक दूंगा।

— phroureo
स्रोत
यदि आप इसे और अधिक गोल्फ कर सकते हैं, तो कृपया ऐसा करें। लेकिन अन्यथा, यह बहुत अच्छा है! PPCG में आपका स्वागत है!
— NoOneIsHere
@NoOneIsHere धन्यवाद! मुझे एहसास हुआ कि मैं अपने फंक्शन का नाम भी छोटा कर सकता हूं;)
— 22 अक्टूबर को
2

एपीएल (डायलॉग यूनिकोड) , 22 = 53 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

⊃⌽⍸(∨⌿↑⊆⍨b)⍷⌽b←2⊥⍣¯1⊢⎕

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

⎕ इनपुट के लिए संकेत

⊢ कि (अलग उपज ¯1से ⎕)

2⊥⍣¯1 आवश्यकतानुसार कई पदों का उपयोग करते हुए बेस -2 में परिवर्तित करें

b← के रूप में की दुकान b(के लिए b inary के लिए)

⌽ उलटा

(… ) उस में निम्नलिखित के प्रारंभिक पदों को चिह्नित करें:

 ⊆⍨b स्व-विभाजन b(अर्थात 1-धारियाँ b)

 ↑ मिश्रण (मैट्रिक्स में सूचियों की सूची बनाएं, शून्य के साथ पैडिंग)

 ∨⌿ ऊर्ध्वाधर या कमी (पैदावार सबसे लंबी लकीर)

⍸ ɩ पदों की शुरुआत के ndices

⌽ उलटा

⊃ पहले वाले को चुनें (यदि कोई भी उपलब्ध नहीं है तो शून्य पैदा करता है)

— एडम
स्रोत
आप पाद में एक
— n को
@ng सही आप हैं।
— आदम
1

MATL , 15 बाइट्स

`tt2/kZ&t]xBnq&

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

आधा और AND का उपयोग करता है। kइसके लिए समाप्त बनाने के लिए आवश्यक ही है1 किसी कारण, 1 और 0.5 रिटर्न 1 के लिए, अनंत लूप के कारण -।

(वैकल्पिक समाधान: BtnwY'tYswb*&X>)- बाइनरी और रन-लंबाई एन्कोडिंग में परिवर्तित करके)

— बी मेहता ने
स्रोत
1

Google शीट, 94 बाइट्स

=Len(Dec2Bin(A1))-Find(MAX(Split(Dec2Bin(A1),0)),Dec2Bin(A1))-Len(MAX(Split(Dec2Bin(A1),0)))+1

नहीं, यह बहुत सुंदर नहीं है। यह स्टोर करने में सक्षम होने के लिए वास्तविक अच्छा होगाDec2Bin(A1)संदर्भ के लिए एक चर के रूप में ।

मुख्य बिंदु: एक्सेल की तरह, Dec2Binफ़ंक्शन का अधिकतम इनपुट मान है 511। इससे बड़ी कोई भी चीज त्रुटि देती है, जैसा कि नीचे देखा गया है।

परिणाम

— इंजीनियर टोस्ट
स्रोत
1

आर, 117 बाइट्स

z=rev(Reduce(function(x,y)ifelse(y==1,x+y,y),strtoi(intToBits(scan())),,,T));ifelse(!sum(z),0,33-which.max(z)-max(z))
— ज़ाहिरो मोर
स्रोत
104 बाइट्स! इसके बजाय rev, Reduce(...,T,T)दाईं ओर से जमा करने के लिए उपयोग करें ( x,yफ़ंक्शन परिभाषा में स्विच करना )। फिर उपयोग करें 1+max(z)-which.max(z)क्योंकि परिणाम कुछ अलग है। "if"इसके बजाय का उपयोग करें "ifelse"क्योंकि हमें वैश्वीकरण की आवश्यकता नहीं है; और अगर आप के any(z)बजाय !sum(z)आप एक बाइट छोड़ का उपयोग करें ।
— ग्यूसेप
मुझे लगता है कि हमें इसे 100 बाइट्स से कम में प्राप्त करने में सक्षम होना चाहिए।
— ग्यूसेप
@giuseppe मुझे लगता है कि आप से पहले यहाँ होने के लिए कुछ हद तक एक धोखा है! कई बार एक गुच्छा tnx करेंगे!
— ज़ाहिरो मोर
लेकिन एक अच्छा तरीका नहीं?
— ज़ाहिरो मोर
1
ओह, कोई चिंता नहीं, मैंने इसे पहले देखा था, लेकिन इसका जवाब देने में ऐसा नहीं लगा, क्योंकि आर बिट संचालन में बहुत बुरा है ... हाँ, अच्छा काम, आपको मेरा +1 मिला
— Giuseppe
1

एक्सेल VBA, 54 44 बाइट्स

-10 बाइट्स का धन्यवाद @EngineerToast

बेनामी VBE तत्काल विंडो फ़ंक्शन जो रेंज से इनपुट लेता है [A1]और VBE तत्काल विंडो में आउटपुट करता है

?Instr(1,StrReverse([Dec2Bin(A1)]),1)+[A1>0]
— टेलर स्कॉट
स्रोत
1
इसके C1बजाय अभी भी वहाँ होने के अलावा A1, मुझे लगता है कि आप Instrशून्य इनपुट सुधार के लिए थोड़ा घुमा के साथ परिणाम सीधे उत्पादन कर सकते हैं : ?Instr(1,StrReverse([Dec2Bin(A1)]),1)+([A1]>0)(46 बाइट्स)। सच = -1 क्योंकि ... VBA।
— इंजीनियर टोस्ट
@EngineerToast - स्वीट! मुझे वह देखना चाहिए था; मैं इसे नोटेशन >0में लाकर 2 बाइट्स को छोड़ने में सक्षम था[A1]
— टेलर स्कॉट
0

Pyth , 17 बाइट्स

यह एक पुनरावर्ती कार्य है। yदिए गए इनपुट पर फ़ंक्शन को कॉल करने के लिए लिंक में शामिल है।

L|&K.&b/b2yKsl|b1

सभी परीक्षण मामलों की जाँच करें।

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

-lK.B|Q1+xKJeScK\0lJ

सभी परीक्षण मामलों की जाँच करें।

— मिस्टर एक्सकोडर
स्रोत
0

आर, 66 बाइट्स

function(i){a=rle(intToBits(i));max(0,a[[1]][which(a[[2]]==1)])}

स्पष्टीकरण:

function(i){
  a = rle(                  # Run-length encode
    intToBits(i)            # The bits in i
  );                        # And assign it to a.
  max(0,                    # Return the maximum of zero and
      a[[1]][               # The lengths of a,
        which(a[[2]]==1)    # But only those where the repeated bit is 1
        ])
}
— जूलियन जुकर
स्रोत
1
यह सबसे लंबी लकीर की लंबाई लौटाता है, इसकी स्थिति नहीं। परीक्षण मामलों और शीर्ष पर चश्मा के खिलाफ जांच करें।
— user2390246
इस उत्तर के सही होते ही मैं अपने डाउनवोट को अपवोट में बदल दूंगा। इसके अलावा, ध्यान दें कि आप a$lइसके बजाय का उपयोग कर सकते हैं a[[1]]और a$vइसके बजाय a[[2]]कुछ बाइट्स को बचाने के लिए :), साथ ही साथ के >0बजाय ==1।
— ग्यूसेप
0

जावास्क्रिप्ट, 54 वर्ण

f=i=>i.toString(2).split(0).sort().reverse()[0].length
  • i.toString(2) पूर्णांक के लिए बाइनरी स्ट्रिंग प्राप्त करता है।
  • .split(0)एक सरणी तत्व में प्रत्येक अनुक्रमिक लोगों हिस्सा हो जाता है।
  • .sort().reverse() हमें पहले के रूप में उच्चतम मूल्य मिलता है।
  • [0].lengthहमें है कि पहले मूल्य की लम्बाई है।
— nl-एक्स
स्रोत
the starting position of number of largest consecutive 1's
— L3viathan
0

पर्ल 5, 45 + 1 (-पी)

(sprintf"%b",$_)=~/(1+)(?!.*1\1)/;$_=length$'

यदि आप इसे अधिकांश गोले की कमांड लाइन पर लिखते हैं, तो आपको इसे इस प्रकार लिखना होगा:

perl -pE'(sprintf"%b",$_)=~/(1+)(?!.*1\1)/;$_=length$'"'"

अंत में उद्धरणों का नृत्य सिर्फ एक को देखने के लिए है ', जो अन्यथा शेल द्वारा भस्म हो जाएगा।

0

रेटिना , ५२ 43 बाइट्स

बाइनरी में कनवर्ट करें, फिर लंबाई के साथ बदलें जो सबसे बड़ी स्ट्रिंग का अनुसरण करता है।

.*
$*
+`(1+)\1
$+0
01
1

$'¶
O`
A-3`
^1+

.

इसे ऑनलाइन आज़माएं - सभी परीक्षण मामले

मार्टिन को धन्यवाद देते हुए 9 बाइट्स बचाए।

— mbomb007
स्रोत
आप के $+लिए उपयोग कर सकते हैं ${1}। लेकिन आप अंतिम चरण को इस तरह चरणों के एक गुच्छा के साथ बदलकर और भी बचा सकते हैं: tio.run/##K0otycxL/K/…
— मार्टिन
@MartinEnder ओके। ${1}Github पर अपने ट्यूटोरियल से नकल किया गया था।
— mbomb007
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.