43

पूर्णांक को देखते हुए n > 0, सबसे लंबे सन्निहित अनुक्रम की लंबाई 0या 1इसके द्विआधारी प्रतिनिधित्व में उत्पादन होता है।

उदाहरण

6110बाइनरी में लिखा है; सबसे लंबा क्रम है 11, इसलिए हमें वापस लौट जाना चाहिए2
16→ 10000→4
893→ 1101111101→5
1337371→ 101000110100000011011→6
1→ 1→1
9965546→ 100110000000111111101010→7

— अरनॉड
स्रोत

8

OEIS A043276

— alephalpha

क्या हम पूर्णांक के आकार की किसी भी सीमा को 32 बिट या 64 बिट की तरह मान सकते हैं?

— xnor

@xnor हाँ आप मान सकते हैं कि इंट 32 बिट्स अधिकतम है

— अरनौद

30

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

f=lambda n,k=1:`k`in bin(n^n/2)and-~f(n,k*10)

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

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

XORing n और n / 2 द्वारा ( 2 बिट द्वारा अनिवार्य रूप से अंतिम बिट को काटते हुए), हमें एक नया पूर्णांक m मिलता है, जिसके अशोधित बिट्स n में आसन्न बिट्स से मेल खाते हैं ।

उदाहरण के लिए, यदि n = 1337371 , हमारे पास निम्नलिखित हैं।

n    = 1337371 = 101000110100000011011₂
n/2  =  668685 =  10100011010000001101₂
m    = 1989654 = 111100101110000010110₂

यह सबसे लंबे समय तक चलने वाले शून्य को खोजने के लिए कार्य को कम करता है। चूंकि सकारात्मक पूर्णांक का बाइनरी प्रतिनिधित्व हमेशा 1 से शुरू होता है , इसलिए हम मी के बाइनरी प्रतिनिधित्व में दिखाई देने वाले अंकों के सबसे लंबे 10 * स्ट्रिंग को खोजने का प्रयास करेंगे । यह पुनरावर्ती रूप से किया जा सकता है।

प्रारंभ k के रूप में 1 । हर बार f निष्पादित होने पर, हम पहले परीक्षण करते हैं कि क्या k का दशमलव प्रतिनिधित्व m के बाइनरी प्रतिनिधित्व में दिखाई देता है । यदि ऐसा है, हम गुणा k द्वारा 10 और कॉल च फिर से। यदि ऐसा नहीं होता है, तो सही के कोड को andनिष्पादित नहीं किया जाता है और हम गलत वापस कर देते हैं ।

ऐसा करने के लिए, हम पहले गणना करते हैं bin(k)[3:]। हमारे उदाहरण में, bin(k)रिटर्न '0b111100101110000010110', और 0b1शुरुआत में इसके साथ हटा दिया जाता है [3:]।

अब, -~पुनरावर्ती कॉल में वृद्धि से पहले हर बार f के लिए एक बार गलत / 0 पुनरावृत्ति कहा जाता है। एक बार जब 10 {j} ( 1 के बाद जे की पुनरावृत्ति 0 ) की बाइनरी प्रतिनिधित्व में प्रकट नहीं होता कश्मीर , में शून्य की सबसे लंबे समय तक रन कश्मीर लंबाई है j - 1 । चूँकि j - 1 लगातार शून्य में k का संकेत j से समीपवर्ती बिट्स n में मिलता है , वांछित परिणाम j है , जिसे हम गलत / 0 बढ़ाकर प्राप्त करते हैं।कुल j समय।

— डेनिस
स्रोत

2

यह वास्तव में चतुर है!

— क्रेगआर 8806

1

वाह, यह चतुर है। कभी इसके बारे में सोच भी नहीं सकता था।

— हाइपरन्यूट्रिनो

10 की शक्तियों के साथ अच्छी चाल, लेकिन क्या वे L के साथ लंबे नहीं हो जाते हैं?

— xnor

@xnor आखिरकार, लेकिन यह सिर्फ एक डेटा प्रकार सीमा है। C, जावास्क्रिप्ट और PHP उत्तर भी इससे पीड़ित हैं।

— डेनिस

यदि उत्पादन में उपयोग किया जाता है तो यह गंभीर रूप से अस्वीकार्य होगा। संक्षेप में (घी) गोल्फ हासिल किया, एक में छेद :)

— JAK

17

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

f=lambda n,r=1:max(r,n and f(n/2,1+~-n/2%2*r))

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

nबार-बार लेने से n/2और उल्टा से द्विआधारी अंक निकालता है n%2। rसमान अंकों के वर्तमान रन की लंबाई को 0 पर रीसेट करके ट्रैक करता है यदि अंतिम दो अंक असमान हैं, तो 1 जोड़ रहा है।

अभिव्यक्ति इस ~-n/2%2बात का सूचक है कि पिछले दो अंक समान हैं, अर्थात n0 या 3 मोडुलो 4. पिछले दो अंकों को एक साथ चेक करना पिछले अंक को याद करने की तुलना में छोटा हो गया है।

— XNOR
स्रोत

14

05AB1E , 6 बाइट्स

b.¡€gM

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

व्याख्या

b       # convert to binary
 .¡     # split at difference
   €g   # map length on each
     M  # take max

— Emigna
स्रोत

2

हा! आखिरकार! के लिए एक उपयोग .¡, मैं इसे इस्तेमाल करने की कोशिश करने के लिए खुद को मजबूर कर सकता हूं।

— मैजिक ऑक्टोपस Urn

@carusocomputing: बहुत यकीन है कि मैं इसे जवाब के एक जोड़े में इस्तेमाल किया है।

— एमिगा

9

गणितज्ञ, 38 बाइट्स

Max[Length/@Split[#~IntegerDigits~2]]&

या

Max[Tr/@(1^Split[#~IntegerDigits~2])]&

— ngenisis
स्रोत

9

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

import re;lambda g:max(map(len,re.findall('1+|0+',bin(g))))

अनाम लम्बा कार्य।

— आर। कप
स्रोत

9

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

BŒgL€Ṁ

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

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

BŒgL€Ṁ  Main link. Argument: n

B       Binary; convert n to base 2.
 Œg     Group adjacent, identical elements.
   L€   Map length over the groups.
     Ṁ  Take the maximum.

— डेनिस
स्रोत

9

रूबी, 41 40 बाइट्स

->b{("%b%b"%[b,~b]).scan(/1+/).max.size}

B या इसके व्युत्क्रम में '1' का सबसे लंबा क्रम ज्ञात कीजिए।

1 बाइट बचाने के लिए मैनटवर्क का धन्यवाद।

— जीबी
स्रोत

2

अन्य संस्करणों के बारे में निश्चित नहीं है, लेकिन 2.3.1 में %b's के बीच के स्थान की कोई आवश्यकता नहीं है ।

— मैनेटवर्क

आप सही हैं, नकारात्मक बाइनरी नंबर ".." से शुरू होते हैं। धन्यवाद।

— जीबी

7

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

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

बहुत अधिक हेरफेर के साथ एक पुनरावर्ती समाधान। nइनपुट को rसंग्रहीत करता है, वर्तमान रन lकी लंबाई को संग्रहीत करता है, सबसे लंबे समय तक चलने की लंबाई को dसंग्रहीत करता है , और पिछले अंक को संग्रहीत करता है।

टेस्ट स्निपेट

f=(n,r=0,l=1,d=2)=>n?f(n>>1,d^n&1?1:++r,r>l?r:l,n&1):l

for(var i of [0,1,2,3,4,5,6,7,8,9,16,893,1337371]) console.log(`f(${i}): ${f(i)}`)

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

— ETHproductions
स्रोत

1

एक ही विचार है, लेकिन अधिक बिट संचालन का उपयोग करना और 0. के लिए अपरिभाषित के डिफ़ॉल्ट रूपांतरण का दोहन करने के लिए स्वतंत्र महसूस हो रहा है:f=(x,b,n,m)=>x?f(x>>1,x&1,n=x&1^b||-~n,m>n?m:n):m

— edc65

7

रूबी, 51 44 43 बाइट्स

समारोह समाधान।

@manatwork जादू से बना है

->s{('%b'%s).scan(/0+|1+/).map(&:size).max}

— मूल्य स्याही
स्रोत

क्या यह लगातार समान अंकों या केवल लगातार 0s के लिए जाँच करता है ?

— ngenisis

2

के लिए 893. गलत परिणाम

— orlp

@orlp अब और नहीं! : डी

— मूल्य इंक

1

मैं 1 और 2 के समाधान को संयोजित करूंगा ->s{s.to_s(2).scan(/0+|1+/).map(&:size).max}:।

— मैनटवर्क

6

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

a=lambda n:n and max((n&-n|~n&-~n).bit_length()-1,a(n/2))

एक पुनरावर्ती समाधान। बिट जादू के लिए एक छोटा रूप हो सकता है।

— orlp
स्रोत

6

पर्ल, 43 बाइट्स

#!perl -p
\@a[$a+=$_-1+($_>>=1)&1||-$a]while$_;$_=@a

शेबबैंग को एक के रूप में गिना जाता है, स्टड से इनपुट लिया जाता है।

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

— Primo
स्रोत

शेबांग की गिनती 0 बाइट्स के रूप में होती है।

— कैलक्यूलेटरफैनलाइन

मेटा पर @CalculatorFeline सर्वसम्मति है कि #!perlशून्य के रूप में गिना जाता है, नहीं #!perl -p।

— प्रिमो

@CalculatorFeline: -pलागत 1, इस धारणा पर है कि अपने पर्ल कमांड लाइन एक तर्क वैसे भी होता है (उदाहरण के लिए -eया -M5.010आप एक पर्ची कर सकते हैं), तो pहाइफ़न का सिर्फ एक के बाद एक में। #!perlनि: शुल्क है (हालांकि अनावश्यक)।

जानकार अच्छा लगा। ।

— कैलक्यूलेटरफैनलाइन

5

पिप , 16 बाइट्स

लगता है कि एक ही अंक के रन पाने के लिए एक छोटा रास्ता होगा ...

MX#*(TBa`1+|0+`)

कमांड-लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

     TBa          1st cmdline arg, To Binary
    (   `1+|0+`)  Find all matches of this regex
  #*              Map length operator to that list
MX                Get the maximum and autoprint it

— DLosc
स्रोत

5

पर्ल 6 , 36 बाइट्स

{(.base(2)~~m:g/1+|0+/)».chars.max}

स्पष्टीकरण:

{                                 }   # a lambda
  .base(2)                            # convert the argument to base 2
          ~~m:g/     /                # regex match, with global matching turned on
                1+|0+                 # match one or more 1, or one or more 0
 (                    )».chars        # replace each match by its length
                              .max    # take the maximum number

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

— SMLS
स्रोत

4

हास्केल, 79 वर्ण

maximum.map length.group.i

कहाँ पे

import Data.List
i 0=[]
i n=mod n 2:i(div n 2)

या ungolfed संस्करण में:

import Data.List
pcg :: Int -> Int
pcg = maximum . map length . group . intToBin

intToBin :: Int -> [Int]
intToBin 0 = []
intToBin n = n `mod` 2 : intToBin (n `div` 2)

स्पष्टीकरण:

intToBinएक इंट्री को बाइनरी अंकों की सूची में परिवर्तित करता है (lsb first)। groupसमूह सन्निहित अनुक्रम, जैसे कि [1, 1, 0, 0, 0, 1]बन जाते हैं [[1, 1],[0, 0, 0],[1]]। maximum . map lengthप्रत्येक आंतरिक सूची की लंबाई के लिए गणना करता है और सबसे लंबे समय तक लंबाई लौटाता है।

संपादित करें: बाइट्स बचाने के लिए @xnor और @Laikoni को धन्यवाद

— user3389669
स्रोत

2

groupडिफ़ॉल्ट रूप से प्रस्तावना में नहीं है, आपको import Data.Listइसका उपयोग करने की आवश्यकता है।

— xnor

1

ध्यान दें कि आप के स्थान पर गार्ड का उपयोग कर सकते let: i n|(q,r)<-n`quotRem`2=r:i q। हमारे हास्केल गोल्फ टिप्स देखें । quotRemहो सकता है divMod। मुझे लगता है कि आप i 0=[]आधार मामले के रूप में उपयोग कर सकते हैं ।

— xnor

1

का उपयोग करना divऔर modसीधे भी कम है i n=mod n 2:i(div n 2):।

— लैकोनी

3

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

heSr8.B

बाइनरी स्ट्रिंग पर लंबाई एन्कोड करें, फिर इसे सॉर्ट करें ताकि सबसे लंबा रन आए, फिर सूची के अंतिम तत्व (सबसे लंबे समय तक चलने) का पहला तत्व (लंबाई) लें।

छद्मकोश में:

'  S     ' sorted(
'   r8   '   run_length_encode(
'     .BQ'     bin(input()) ))  \
'he      '   [-1][0]

— busukxuan
स्रोत

3

जे , 21 बाइट्स

[:>./#:#;.1~1,2~:/\#:

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

व्याख्या

[:>./#:#;.1~1,2~:/\#:  Input: integer n
                   #:  Binary digits of n
              2   \    For each continuous subarray of 2 digits
               ~:/       Reduce it using not-equals
            1,         Prepend a 1 to those results
     #:                Binary digits of n
        ;.1~           Cut the binary digits at each location with a 1
       #                 Get the length of each cut
[:>./                  Reduce those lengths using maximum and return

— मील की दूरी पर
स्रोत

3

MATLAB 71 बाइट्स

m=1;a=diff(int8(dec2bin(a)));while(any(a==0)),m=m+1;a=diff(a);end;m

यह पूर्णांक चर 'a' को बाइनरी इंट 8 सरणी में परिवर्तित करता है, फिर परिणाम की संख्या को गिनता है जब तक कि परिणाम में कोई शून्य न हो।

मैं यहाँ नया हूँ। क्या पीसीजी नियमों द्वारा इस तरह के इनपुट और वन-लाइनर की अनुमति है?

— पहला
स्रोत

3

PPCG में आपका स्वागत है! डिफ़ॉल्ट रूप से, केवल फ़ंक्शन या पूर्ण प्रोग्राम (कोड स्निपेट नहीं) स्वीकार किए जाते हैं। आपके मामले में इसका मतलब है कि आपको इनपुट aकरना होगा a=input('');। इसके अलावा, कुछ गोल्फ सलाह: के ~aबजाय a==0। क्या आपको वास्तव में जरूरत है int8)?

— लुइस मेंडो

3

सप्टक , 31 बाइट्स

@(n)max(runlength(+dec2bin(n)))

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

व्याख्या

यह मेरे MATL उत्तर का अनुवाद है। मेरी प्रारंभिक योजना एक अलग दृष्टिकोण थी, अर्थात् @(n)max(diff(find(diff([0 +dec2bin(n) 0]))))। लेकिन यह पता चला है कि ऑक्टेव का एक runlengthफ़ंक्शन है (जो मुझे अभी पता चला है)। डिफ़ॉल्ट रूप से यह केवल रन-लेंथ के सरणी को आउटपुट करता है, इसलिए वांछित परिणाम maxउस सरणी का है। का आउटपुट dec2bin, जिसमें एक चार सरणी (स्ट्रिंग) है , '0'और '1', एक संख्यात्मक सरणी में परिवर्तित करने की आवश्यकता है +, क्योंकि runlengthसंख्यात्मक इनपुट की उम्मीद है।

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

3

बैश / यूनिक्स उपयोगिताओं, 66 65 42 बाइट्स

महत्वपूर्ण सुधार (23 बाइट्स!) के लिए @DigitalTrauma का धन्यवाद।

dc<<<`dc -e2o?p|fold -1|uniq -c|sort -n`rp

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

— मिशेल स्पेक्टर
स्रोत

1

@DigitalTrauma सुधार के लिए धन्यवाद, विशेष रूप से तह सहित, जो मेरे सामान्य शस्त्रागार में नहीं था।

— मिशेल स्पेक्टर

3

बैश (+ कोर्यूटिल्स, + जीएनयू ग्रीप), 33, 32 बाइट्स

संपादन:

माइनस 1 बाइट ( grep अभिव्यक्ति के आसपास हटाए गए उद्धरण )

golfed

dc -e2o$1p|grep -Po 1+\|0+|wc -L

व्याख्या की

 #Convert to binary
 >dc -e2o893p
 1101111101

 #Place each continuous run of 1es or 0es on its own line
 >dc -e2o893p|grep -Po '1+|0+'
 11
 0
 11111
 0
 1

 #Output the length of the longest line
 >dc -e2o893p|grep -Po '1+|0+'|wc -L
 5

यह ऑनलाइन की कोशिश करो!

— टसेपेल्लिन
स्रोत

AFAIK, grep न तो बैश का हिस्सा है और न ही कोर्यूटिल्स का, हालांकि इसका रखरखाव और वितरण अपने स्वयं के द्वारा किया जाता है । डीसी के बारे में निश्चित नहीं है, लेकिन यह जीएनयू दुनिया में एक स्टैंडअलोन उपकरण हुआ करता था। कोरुटिल्स का केवल एक बनाने वाला भाग wc है।

— मोरकी

@Moreaki, grep POSIX है, इसलिए किसी भी शेल-आधारित उत्तर का अर्थ है कि यह पहले से ही उपलब्ध है। डीसी POSIX नहीं है, लेकिन लगभग हर * निक्स प्रणाली का एक मानक हिस्सा है, इसलिए इसे आमतौर पर एक अलग निर्भरता के रूप में भी उल्लेख नहीं किया गया है।

— ज़ेपेलिन

मुझे लगता है कि हम यहाँ विचारों की दो अलग-अलग गाड़ियों पर हैं: मेरी बात यह नहीं थी कि अगर grep POSIX था या नहीं, मेरी बात यह थी कि मुझे आपके प्रस्तुत करने के शीर्षक ने संकेत दिया कि आपके समाधान कार्य को करने के लिए bash + coreutils की आवश्यकता होगी, जबकि ऐसा नहीं लगता। जब मैंने इसे पहली बार पढ़ा, तो यह जानकारी मुझे भ्रमित कर रही थी। यदि आप macOS शिप बैश शेल पर अपने समाधान की कोशिश करते हैं, तो यह काम नहीं करेगा; और इससे कोई फर्क नहीं पड़ता कि आपने कोरुटिल स्थापित किया है या नहीं; आपको इसे काम करने के लिए GNU grep की आवश्यकता होगी।

— मोरकी

@ मोरेकी, हां, मैं सिर्फ जीएनयू प्रणाली का अर्थ करता हूं, जब मैं कहता हूं कि + कोर्यूटिल्स, अल्थ्रिन जो हमेशा मामला नहीं होता है। मैंने शीर्षक अधिक सटीक होने के लिए अद्यतन किया है।

— जेपेलिन

2

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

$b@b:lotl

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

व्याख्या

$b          List of binary digits of the input
  @b        Runs of consecutive identical digits in that list
    :lo     Order those runs by length
       tl   Output is the length of the last one

— Fatalize
स्रोत

2

सी #, 106 बाइट्स

n=>{int l=1,o=0,p=0;foreach(var c in System.Convert.ToString(n,2)){o=c!=p?1:o+1;l=o>l?o:l;p=c;}return l;};

प्रारूपित संस्करण:

System.Func<int, int> f = n =>
{
    int l = 1, o = 0, p = 0;
    foreach (var c in System.Convert.ToString(n, 2))
    {
        o = c != p ? 1 : o + 1;

        l = o > l ? o : l;

        p = c;
    }

    return l;
};

और 118 बाइट्स पर सूचकांक द्वारा स्ट्रिंग तक पहुंचने वाला एक वैकल्पिक तरीका, व्हॉट्सएप को हटा दिया गया:

System.Func<int, int> f2 = n =>
{
    var s = System.Convert.ToString(n, 2);

    int l = 1, c = 1, i = 0;

    for (; i < s.Length - 1; )
    {
        c = s[i] == s[++i] ? c + 1 : 1;
        l = l < c ? c : l;
    }

    return l;
};

— TheLethalCoder
स्रोत

2

जावास्क्रिप्ट, 66 बाइट्स

x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.leng‌th))

कोड के लिए मैनटवर्क का धन्यवाद ।

व्याख्या

x.toString(2)

संख्या को बाइनरी स्ट्रिंग में बदलें।

split(/(0+|1+)/g)

हर अलग चरित्र को विभाजित करें (0 या 1) (यह रेगेक्स खाली स्थानों को पकड़ता है लेकिन उन्हें अनदेखा किया जा सकता है)

map(y=>y.length)

सरणी के प्रत्येक तत्व के लिए इसकी लंबाई प्राप्त करें और इसे दिए गए सरणी में डालें।

...

तर्क की सूची में सरणी बदलें ([1,2,3] -> 1,2,3)

Math.max()

तर्कों में से सबसे बड़ी संख्या प्राप्त करें।

— समुदाय
स्रोत

1

प्रेरणा के लिए वैल्यू इंक के रूबी समाधान को जमा करके , इसे रूपांतरित किया जा सकता है x=>x.toString(2).split(/(0+|1+)/g).map(y=>y.length).sort().pop()। या समान लंबाई x=>Math.max(...x.toString(2).split(/(0+|1+)/g).map(y=>y.length)):।

— मैनावर्क

3

मुझे लगता है कि आपको सॉर्ट फ़ंक्शन के लिए एक विधेय जोड़ना पड़ सकता है sort((a,b)=>b-a)। डिफ़ॉल्ट रूप से, प्रकार समारोह स्थानों 10के बीच में 1और 2।

— मामा फन रोल

या आप मैथ.मैक्स का उपयोग कर सकते हैं, जैसा कि मैनटवर्क ने सुझाव दिया था।

— मामा फन रोल

Wtf, लेकिन वे संख्याएँ हैं। जेएस कृपया।

2

आश्चर्य है , 27 बाइट्स

max.map#len.mstr`0+|1+`g.bn

उपयोग:

(max.map#len.mstr`0+|1+`g.bn)123

बाइनरी में कनवर्ट करता है, 0 और 1 के प्रत्येक क्रम से मेल खाता है, प्रत्येक मैच की लंबाई प्राप्त करता है, और अधिकतम प्राप्त करता है।

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

क्या यह इनपुट को बाइनरी में बदलता है?

— लकोनी

oooooh मुझे वह हिस्सा याद आ गया। क्विक फिक्स: पी

— मामा फन रोल

2

बैच, 102 बाइट्स

@set/a"n=%1/2,d=%1%%2,r=1+(%3+0)*!(0%2^d),l=%4-(%4-r>>5)
@if not %n%==0 %0 %n% %d% %r% %l%
@echo %l%

@ Edc65 के उत्तर का पोर्ट। %2.. %4पहली कॉल पर खाली हो जाएगा, इसलिए मुझे भाव इस तरह से लिखना होगा कि वे अभी भी काम करेंगे। सबसे सामान्य मामला वह है %3जो मुझे लिखना था (%3+0)। %2यह आसान है, जैसा कि यह केवल 0या हो सकता है 1, जो अष्टक में समान हैं, इसलिए 0%2यहां काम करता है। %4यह और भी आसान हो गया है, क्योंकि मुझे केवल इससे घटाना है। (%4-r>>5)इसका उपयोग बैच के lसाथ तुलना ऑपरेटर के rरूप में तुलना करने के लिए किया जाता है set/a।

— नील
स्रोत

2

दिल्लोग एपीएल , 22 बाइट्स

अनाम फ़ंक्शन ट्रेन

⌈/∘(≢¨⊢⊂⍨1,2≠/⊢)2⊥⍣¯1⊢

⌈/∘(... निम्नलिखित अनाम फ़ंक्शन-ट्रेन के परिणामों की अधिकतम ...

≢¨ प्रत्येक का मिलान

⊢⊂⍨ तर्क का विभाजन, जहां विभाजन में लोगों द्वारा निर्धारित किया जाता है

1, एक करने के लिए तैयार है

2≠/ की जोड़ीदार असमान

⊢ बहस

) पर लागू किया गया

2⊥⍣¯1 आधार -2 से एक बार नकारात्मक लागू किया (यानी आधार -2, एक बार)

⊢ बहस

TryAPL ऑनलाइन!

— एडम
स्रोत

2

जाप, 15 बाइट्स

2o!q¢ c ml n gJ

इसे ऑनलाइन टेस्ट करें! या एक बार में सभी परीक्षण मामलों को सत्यापित करें ।

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

                 // Implicit: U = input integer, J = -1
2o               // Create the range [0...2), or [0,1].
  ! ¢            // Map each item Z in this range to U.s(2)
   q             //                                        .q(Z).
                 // This returns the runs of 1's and 0's in the binary
                 // representation of U, respectively.
      c          // Flatten into a single list.
        ml       // Map each item Z to Z.length.
           n gJ  // Sort the result and grab the item at index -1, or the last item.
                 // This returns the largest element in the list.
                 // Implicit: output result of last expression

— ETHproductions
स्रोत

2

आर, 45 34 बाइट्स

max(rle(miscFuncs::bin(scan()))$l)

@Rturnbull और @plannapus के लिए एक मूर्खतापूर्ण गलतफहमी तय।

— Billywob
स्रोत

शायद मुझे कुछ याद आ रहा है, लेकिन क्या इनपुट एक पूर्णांक नहीं होना चाहिए, न कि बाइनरी नंबर? और हम अधिकतम की तलाश कर रहे हैं 0या 1नहीं 0, ठीक है?

— 08:०ull पर rturnbull

@plannapus मैं ईमानदारी से नहीं जानता। कल्पना पूरी तरह से छूट गई होगी। अब तय हो गया।

— बिलीवोब

2

पॉवरशेल , 78 74 73 बाइट्स

([regex]::Matches([convert]::ToString("$args",2),'0+|1+')|% Le*|sort)[-1]

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

उह उन .Net विधियाँ।

यह सिर्फ लोगों और शून्य के सन्निहित दृश्यों को खोजने (और मैच) के लिए एक रेगेक्स का उपयोग करता है, फिर यह Lengthसंपत्ति लेता है (एक नए पैटर्न के साथ जो मैंने पाया कि थोड़े ज्ञात पैरामीटर सेट का उपयोग करता है ForEach-Object, जिसके परिणामस्वरूप 1 बाइट को बचाने के लिए) मैच ऑब्जेक्ट्स उन्हें क्रमबद्ध करें, और पिछले एक (सबसे बड़ा) को आउटपुट करता है।

— briantist
स्रोत

1

जे, 27 बाइट्स

>./>#&.>((1,2~:/\[)<;.1])#:

मील के उत्तर के लिए थोड़ा अलग (और दुर्भाग्य से लंबा) दृष्टिकोण ।

उपयोग:

    >./>#&.>((1,2~:/\[)<;.1])#:893
5

व्याख्या

>./>#&.>((1,2~:/\[)<;.1])#:
                         #: Convert to base 2
        (               )   A fork
                       ]    Previous result
         (1,2~:/\[)         Find where each new sequence begins
                   <;.1     Cut the string of integers based on where each sequence begins and box them
    #&.>                    Count under open - open each box and count the items in it
>./>                        Open all the boxes and find the maximum value

— गैरेथ
स्रोत

मुझे नहीं लगता कि यह मान्य है - यह एक फ़ंक्शन नहीं है और इसलिए यह एक स्निपेट है।

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

@ ConorO'Brien ठीक है, मैं इसे बाद में फिर से देखूंगा।

— गैरेथ

बिट रन रनडाउन

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

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

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

05AB1E , 6 बाइट्स

गणितज्ञ, 38 बाइट्स

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

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

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

रूबी, 41 40 बाइट्स

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

टेस्ट स्निपेट

रूबी, 51 44 43 बाइट्स

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

पर्ल, 43 बाइट्स

पिप , 16 बाइट्स

व्याख्या

पर्ल 6 , 36 बाइट्स

हास्केल, 79 वर्ण

स्पष्टीकरण:

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

जे , 21 बाइट्स

व्याख्या

सप्टक , 31 बाइट्स

व्याख्या

बैश / यूनिक्स उपयोगिताओं, 66 65 42 बाइट्स

बैश (+ कोर्यूटिल्स, + जीएनयू ग्रीप), 33, 32 बाइट्स

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

व्याख्या

सी #, 106 बाइट्स

जावास्क्रिप्ट, 66 बाइट्स

व्याख्या

आश्चर्य है , 27 बाइट्स

बैच, 102 बाइट्स

दिल्लोग एपीएल , 22 बाइट्स

जाप, 15 बाइट्स

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

आर, 45 34 बाइट्स

पॉवरशेल , 78 74 73 बाइट्स

जे, 27 बाइट्स