एक स्ट्रिंग में एक चरित्र का सबसे लंबा रन

19

आपकी चुनौती: एक फ़ंक्शन लिखें s, जो एक स्ट्रिंग , एक चरित्र लेता है c, और सबसे लंबे समय तक चलने की लंबाई पाता cहै s। रन की लंबाई होगी l।

नियम :

  • यदि sलंबाई 0 है या cखाली है, lतो 0 होना चाहिए।
  • का कोई उदाहरण नहीं हैं, तो cमें s, l0 होना चाहिए।
  • मानक कमियां और मानक I / O नियम लागू होते हैं।
  • कोई फर्क नहीं पड़ता कि एस sके रन में कहाँ cस्थित है, lवही होना चाहिए।
  • किसी भी प्रिंट योग्य ASCII वर्ण में प्रदर्शित हो सकता sहै और c।

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

s,c --> l
"Hello, World!",'l'  -->  2
"Foobar",'o'         -->  2
"abcdef",'e'         -->  1
"three   spaces",' ' -->  3
"xxx xxxx xx",'x'    -->  4
"xxxx xx xxx",'x'    -->  4
"",'a'               -->  0
"anything",''        -->  0

विजेता :

कोड-गोल्फ के साथ प्रत्येक भाषा में सबसे छोटा उत्तर जीतता है।

code-golf  string 
— एमडी एक्सएफ
स्रोत
— एमडी एक्सएफ
क्या आप खाली के किनारे वाले मामलों को शामिल कर सकते हैं sऔर जो आपके परीक्षण के मामलों में cगैर-खाली नहीं sहै?
— मार्टिन एंडर
वर्णों की कौन सी श्रेणी s/ में दिखाई दे सकती है c?
— मार्टिन एंडर
6
cखाली हो सकता है? कई भाषाओं में, एक चरित्र सिर्फ विशेष शब्दार्थ के साथ एक पूर्णांक है, और आपके पास वास्तव में एक खाली पूर्णांक भी नहीं हो सकता है।
— मार्टिन एंडर
14
यह वास्तव में मेरे लिए कोई मतलब नहीं है। आपके परीक्षण मामलों से पता चलता है कि हमें इसका समर्थन करना है। अगर हमें इसका समर्थन नहीं करना है, तो इसके आवश्यक आउटपुट को निर्दिष्ट करने का कोई मतलब नहीं है, क्योंकि मैं हमेशा कह सकता हूं कि यह समर्थित नहीं है अगर मेरा समाधान उस मामले में कुछ और करेगा।
— मार्टिन एंडर

जवाबों:

12

05AB1E , 5 बाइट्स

कोड:

SQγOM

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

SQ      # Check for each character if it is equal to the second input
  γ     # Split the list of zeros and ones into groups
   O    # Sum each array in the arrays
    M   # Get the maximum
— अदनान
स्रोत
2
अच्छा समाधान! मुझे पता था कि इस तरह से करने का एक तरीका है, मैं इसके बारे में सोच भी नहीं सकता था।
— रिले
γ¢Mऐसा प्रदर्शन नहीं कर रहा हूं जैसा मैंने सोचा था कि यह सोचा होगा कि यह 3-बाइट होगा।
— मैजिक ऑक्टोपस Urn
8

मैथेमेटिका, 35 बाइट्स

Max[Tr/@Split@Boole@Thread[#==#2]]&

शुद्ध फ़ंक्शन इनपुट के रूप में वर्णों और एक अन्य चरित्र की सूची ले रहा है और एक nonnegative पूर्णांक लौटा रहा है। अदनान के अवलोकन (अपवोट!) का उपयोग करते हुए मेरे पहले प्रयास में सुधार हुआ है कि किसी को सरणी को विभाजित करने से पहले विशेष चरित्र की बराबरी के लिए परीक्षण करना चाहिए।

Thread[#==#2]जाँचता है कि पहले तर्क में प्रत्येक इनपुट वर्ण दूसरे तर्क के रूप में दिए गए वर्ण के बराबर है। Booleपरिणामी Trues और Falses को 1s और 0s में परिवर्तित करता है । Splitलगातार तत्वों के रन में सूची को विभाजित करता है; Tr/@प्रत्येक सबलिस्ट को sums, और Maxविजेता पाता है। (कैसे Maxकाम करता है, अगर पहली दलील खाली सूची है, तो यह फ़ंक्शन वापस आ जाता है -∞। इसलिए, आप जानते हैं, ऐसा मत करो।)

पहला सबमिशन (51 बाइट्स)

Max[Split@#/.a:{c_String..}:>Boole[c==#2]Length@a]&

Split@#इनपुट को लगातार पात्रों के रनों में विभाजित करता है, जैसे {{"t"}, {"h"}, {"r"}, {"e", "e"}, {" ", " ", " "}, {"s"}, {"p"}, {"a"}, {"c"}, {"e"}, {"s"}}कि चौथे टेस्ट केस के लिए। /.a:{c_String..}:>प्रत्येक उपसूचक बदल देता aहै कि एक दोहराया चरित्र की एक सूची है cद्वारा Length@aसे गुणा Boole[c==#2]है, जो 1यदि cइनपुट चरित्र के बराबर होती है और 0अन्यथा। फिर Maxजवाब निकालता है।

— ग्रेग मार्टिन
स्रोत
7

जाप , 20 18 15 बाइट्स

fV+Vî+)ª0)n o l

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

Obarakon और ETHproductions के लिए 5 बाइट्स को सहेजा गया

— टॉम
स्रोत
1
मैं थोड़ी देर के लिए अपने स्वयं के समाधान के साथ खेला और एक के साथ समाप्त हुआ जो लगभग आपका था, लेकिन कम था। यदि आप उपयोग करते हैं fV+Vî+)... तो मैं आपको बाकी का पता लगाने
— दूंगा
@ETHproductions "If s is of length 0 or c is empty, l should be 0", मैं इसे सचमुच ले जा सकता हूं
— टॉम
ओह, मुझे एहसास नहीं हुआ कि जब sभी कोई उदाहरण नहीं होता है तो वह विफल हो जाता है c।
— ETHproductions
7

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

f=lambda s,c:+(c in s)and-~f(s,c+c[0])

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

डेनिस ने cडुप्लिकेट अक्षरों की एक स्ट्रिंग को अद्यतन करके 3 बाइट्स को बचाया, बजाय एक संख्या को पुन: अद्यतन करने के लिए गुणा cकरके।

— XNOR
स्रोत
1
f=lambda s,c:c in s and-~f(s,c+c[0])6 बाइट्स बचाता है (3 यदि झूठी अनुमति नहीं है)।
— डेनिस
5

05AB1E , 11 6 बाइट्स

-5 बाइट्स carusocomputing के लिए धन्यवाद

γvy²¢M

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

γ      # split into chunks of consecutive equal elements
 vy    # For each chunk...
   ²¢  #  Count the number of input characters in this chunk
     M #  Push the largest count so far
— रिले
स्रोत
γvy²¢M6-बाइट्स के लिए, एक ही विचार।
— मैजिक ऑक्टोपस Urn
4

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

f c=maximum.scanl(\n k->sum[n+1|c==k])0

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

स्ट्रिंग के माध्यम से चलाएं और वर्तमान चार को एक काउंटर के साथ बदलें जो जब भी बढ़ा हो cया 0नहीं तो रीसेट हो । सूची का अधिकतम लाभ उठाएं।

4 बाइट्स के लिए @xnor को धन्यवाद।

— nimi
स्रोत
आप कर सकते हैं sum[n+1|c==k]।
— xnor
@ एक्सनोर: अच्छा! मैंने *fromEnum(c==k)पॉइंटफ्री और लैम्ब्डा दोनों के साथ प्रयोग किया है , लेकिन यह हमेशा 2 या 3 बाइट्स लंबा था।
— nimi
4

सी # 116 115 बाइट्स

मेरा पहला कोड गोल्फ

संपादित क्योंकि प्रारंभिक प्रस्तुत एक स्निपेट था और रेगेक्स के लिए आवश्यक नामस्थान गायब था

विशेष रेगेक्स अर्थ वाले वर्णों का समर्थन करने के लिए # 2 पूर्ण पुनर्लेखन को संपादित करें

System.Linq? s => c => System.Text.RegularExpressions.Regex.Replace (s, "[^" + c + "]", ++ c + "") का उपयोग करते हुए। स्प्लिट (c) .Max (x =>) x.Length);

using System.Linq;s=>c=>{var r=(char)(c-1);return string.Join("",s.Select(x=>x==c?c:r)).Split(r).Max(x=>x.Length)};
— झाड़ू
स्रोत
3
मैं C # नहीं जानता, लेकिन ऐसा लगता है कि आपका कोड वैरिएबल की अपेक्षा करता है cऔर sपूर्वनिर्धारित होना चाहिए। हम इसे "कोड-स्निपेट" कहते हैं और इसकी अनुमति नहीं है। आप संभवतः एक अनाम फ़ंक्शन के रूप में अपने कोड का पुनर्गठन कर सकते हैं या उन चर को इनपुट पर सेट कर सकते हैं। दोनों की अनुमति है।
— गेहूं जादूगर
क्या वह काम करता है? (ऊपर संपादित देखें)
— ब्रूम
1
एक बार फिर मुझे C # नहीं पता है, लेकिन ऐसा लगता है कि यह करता है। आप हमारे चेकआउट करने के लिए चाहते हो सकता है सुझावों सी # में गोल्फ के लिए यहाँ सी # में अधिक अनुभवी सलाह के लिए।
— गेहूं जादूगर
लिंक के लिए धन्यवाद! मैं निश्चित रूप से C # टिप्स
— ब्रूम
3
नमस्ते, सी # में गोल्फिंग के लिए कुछ सामान्य टिप्पणियां, आप अपने कार्य को इस प्रकार परिभाषित कर सकते हैं (s,c)=>। आपको System.Text.RegularExpressions.Regexअपने फ़ंक्शन से ठीक पहले एक उपयोग कथन जोड़ना या जोड़ना होगा।
— LiefdeWen
4

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

-2 बाइट्स का शुक्रिया @Neil
-1 बाइट की बदौलत @apsillers को

s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j

करी सिंटैक्स में इनपुट लेता है f("foobar")("o"):।

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

f=
s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j
String: <input id=I> Letter: <input id=J maxlength=1 size=1> <button onclick='O.innerHTML+=`f("${I.value}")("${J.value}") = ${f(I.value)(J.value)}\n`'>Run</button><pre id="O"></pre>
स्निपेट का विस्तार करें

एक अन्य विकल्प का उपयोग कर evalऔर for(54 बाइट्स)

s=>c=>eval("i=j=0;for(x of s)i=x==c&&i+1,i>j?j=i:0;j")

रेगेक्स (85 बाइट्स) का उपयोग करके पुराना उत्तर

s=>c=>c?Math.max(...s.match(eval(`/${/\w/.test(c)?c:"\\"+c}*/g`)).map(x=>x.length)):0
— जस्टिन मेरिनर
स्रोत
1
मुझे लगता है कि x==c?i++:i=0बस हो सकता है i=x==c&&i+1के बाद से एक falseपर परिणाम x==cतुलना एक के रूप में माना जाएगा 0(सहित, और वापसी मान कभी नहीं होगा किसी भी संख्या के बाद से, संख्यात्मक तुलना और वेतन वृद्धि के लिए 0, में jहमेशा से अधिक शून्य की तरह वरीयता दी जाएगी falseमें i)
— apsillers
@apsillers धन्यवाद, अपडेट किया गया, लेकिन आपका क्या मतलब है कि यह कभी रिटर्न वैल्यू नहीं रहा?
— जस्टिन मेरिनर
गलतफहमी के लिए खेद है; मैं सिर्फ यह समझा रहा था कि परिवर्तन आपके कार्यक्रम को कभी वापस नहीं false
— लाएगा
1
s=>c=>[...s].map(x=>j=(x!=c?i=0:++i)>j?i:j,i=j=0)&&jकुछ बाइट्स बचाने के लिए लगता है।
— नील
1
क्षमा करें, मैंने गलत कोड पोस्ट किया, मेरा मतलब पोस्ट करना था f=s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j, जो बाइट कम है।
— नील
4

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 75 72 बाइट्स

(s,c)=>Math.max(0,...(for(s of s.split(/((.)\2*)/))if(s[0]==c)s.length))

ES6 संगत स्निपेट:

f=
(s,c)=>Math.max(0,...s.split(/((.)\2*)/).filter(s=>s[0]==c).map(s=>s.length))
<div oninput=o.textContent=f(s.value,c.value)><input id=s><input id=c maxlength=1 size=1><pre id=o>0
स्निपेट का विस्तार करें

split खाली स्ट्रिंग्स और एकल पात्रों के साथ-साथ रनों का एक गुच्छा लौटाता है लेकिन यह परिणाम को प्रभावित नहीं करता है।

— नील
स्रोत
2

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

->$_,$c {$c&&$_??.comb(/$c+/)».chars.max!!0}

झसे आज़माओ

->$_,$c {$c&&$_??.comb(/$c+/).max.chars!!0}

झसे आज़माओ

->$_,$c {$c&$_??.comb(/$c+/).max.chars!!0}

झसे आज़माओ

विस्तारित:

-> $_, $c {       # pointy block lambda

    $c & $_       # AND junction of $c and $_
                  #   empty $c would run forever
                  #   empty $_ would return 4 ( "-Inf".chars )

  ??              # if True (neither are empty)

    .comb(/$c+/)  # find all the substrings
    .max          # find the max
    .chars        # get the length

  !!              # if False (either is empty)

    0             # return 0
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

जावास्क्रिप्ट, ईएस 6, 52

पुनरावर्ती समाधान जो स्ट्रिंग इनपुट को एक सरणी के रूप में मानता है (ध्यान दें: प्रारंभिक इनपुट अभी भी एक स्ट्रिंग है) और चरित्र में बाएं-से-दाएं खपत करता है C:

f=([C,...s],c,t=0,T=0)=>C?f(s,c,C==c&&++t,t>T?t:T):T

में वर्तमान रन पटरियों tऔर में सबसे अच्छा वैश्विक T।

स्पष्टीकरण:

f=            // function is stored in `f` (for recursion)
  ([C,...s],  // turn input string in first-char `C` and the rest in `s`
   c,         // argument `c` to search for
   t=0,T=0)   // current total `t`, best total `T`
     =>
        C?             // if there is still any char left in the string
          f(s,c,       // recursively call `f`
            C==c&&++t, // increment `t` if char is match, or set `t` to `false`
            t>T?t:T)   // set global `T` to max of `t` and `T`
          :T           // when string is depleted, return `T`

स्थापना tकरने के लिए falseगैर मैचों पर काम करता है, क्योंकि जब भी tवृद्धि की जाती है, falseके रूप में व्यवहार किया जाता है 0(यानी, false + 1है 1), और falseवैश्विक-अधिकतम में किसी भी मूल्य से पिसाई यंत्र की तुलना कभी नहीं होगा T।

— apsillers
स्रोत
1
अच्छा समाधान, मैं [C,...s]वाक्य रचना से अपरिचित था । मुझे slice()अपने स्वयं के पोस्ट से बाइट्स में मदद करनी चाहिए ।
— रिक हिचकॉक
2

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

=ŒgṀS

यह एक डाइएडिक लिंक / फ़ंक्शन है जो एक स्ट्रिंग और एक चरित्र लेता है। ध्यान दें कि यह एक पूर्ण कार्यक्रम के रूप में काम नहीं कर सकता है, क्योंकि कमांड-लाइन तर्कों से इनपुट पायथन सिंटैक्स का उपयोग करता है, और पायथन - जेली के विपरीत - वर्णों से सिंगलटन स्ट्रिंग्स को अलग नहीं करता है।

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

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

=ŒgṀS  Main link. Left argument: s (string). Right argument: c (character)

=      Compare all characters in s with c, yielding 1 for c and 0 otherwise.
 Œg    Group adjacent, equal Booleans in the resulting array.
   Ṁ   Take the maximum. Note that any array of 1's will be greater than any array
       of 0's, while two arrays of the same Booleans are compared by length.
    S  Take the sum, yielding the length for an array of 1's and 0 otherwise.
— डेनिस
स्रोत
2

एपीएल (डायलॉग) , 18 11 बाइट्स

संस्करण 16.0 या (कई प्रणालियों पर डिफ़ॉल्ट) के ⊂साथ स्वैपिंग की आवश्यकता है ।⊆⎕ML←3

⌈/0,≢¨⊂⍨⎕=⎕

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

⎕=⎕ दो इनपुट के बीच समानता के लिए बूलियन

⊂⍨ स्व-विभाजन (विभाजन शुरू करें जहां एक गैर-शून्य तत्व अपने पूर्ववर्ती से अधिक है)

≢¨ टैली प्रत्येक

0, शून्य को खाली करें (रिक्त-इनपुट मामलों के लिए)

⌈/ अधिकतम उन

पुराना हल

एस के लिए पहले संकेत , फिर सी के लिए

⌈/0,(⎕,¨'+')⎕S 1⊢⎕

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

⎕ एस के लिए शीघ्र

⊢ उसके लिए

(… )⎕S 1पीसीआर एस की घटनाओं की लंबाई के लिए खोज

 '+' एक प्लस प्रतीक (मतलब एक या अधिक)

 ,¨  के तत्वों में से प्रत्येक के लिए संलग्न

 ⎕ संकेत के लिए c

0, शून्य को खाली करें (रिक्त-इनपुट मामलों के लिए)

⌈/ अधिकतम उन

c को संलग्न स्ट्रिंग के 1-तत्व वेक्टर के रूप में दिया जाना चाहिए, यदि उसे भागने की आवश्यकता है।

— एडम
स्रोत
2

PHP, 70 67 बाइट्स

तीन संस्करण:

while(~$c=$argv[1][$i++])$x=max($x,$n=($c==$argv[2])*++$n);echo+$x;
while(~$c=$argv[1][$i++])$x=max($x,$n=$c==$argv[2]?++$n:0);echo+$x;
for(;++$n&&~$c=$argv[1][$i++];)$x=max($x,$n*=$c==$argv[2]);echo+$x;

कमांड लाइन तर्कों से इनपुट लेता है; ऑनलाइन चलाएं -rया उनका परीक्षण करें ।

— टाइटस
स्रोत
2

PHP , 70 बाइट्स

for(;~$c=$argv[1][$i++];)$r[]=$argv[2]==$c?++$n:$n=0;echo$r?max($r):0;

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

PHP , 75 बाइट्स

for(;~$s=substr($argv[1],$i++);)$r[]=strspn($s,$argv[2]);echo max($r?:[0]);

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

पीएचपी , 83 बाइट्स

<?=@preg_match_all("<".preg_quote($argv[2])."+>",$argv[1],$t)?strlen(max($t[0])):0;

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

बचने के लिए +8 बाइट्स @ 

<?=($a=$argv[2])&&preg_match_all("<".preg_quote($a)."+>",$argv[1],$t)?strlen(max($t[0])):0;
— जार्ग हुल्सरमैन
स्रोत
67 बाइट्स संस्करण किसी भी रेगेक्स विशेष चार (और #निश्चित रूप से) के लिए विफल हो जाएगा ।
— टाइटस
... और के ~लिए असफल हो सकता है chr(207)।
— टाइटस
@ टिट्स हो गया और इनपुट केवल
— अस्सी के
के लिए अच्छी आंख ++$n! आप प्रिंट करने योग्य अभिसारी थे। ;)
— टाइटस
1
echo$r?max($r):0;एक बाइट बचाता है
— टाइटस
2

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

(@ बिएल के लिए 7 बाइट्स धन्यवाद, और @ हर्मनलॉइनस्टीन के लिए 2 बाइट्स धन्यवाद।)

s=>g=c=>c&&s.includes(c)?1+g(c+c[0]):0

स्पष्टीकरण:

जब तक कोई नहीं मिलता है, तब तक लंबे समय तक खोज करता है।

स्निपेट:

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

— रिक हिचकॉक
स्रोत
1
बहुत आसन! प्रतिभाशाली!
— अप्सिलर्स
क्या आप नहीं कर सकते f=(s,c)=>c&&s.includes(c)&&1+f(s,c+c[0])?
— नील
या बेहतर अभी भी, यह करने के लिए करी s=>g=c=>c&&s.includes(c)&&1+g(c+c[0])।
— नील
यह लगभग काम करता है, लेकिन यह "झूठे" और पिछले दो मामलों के लिए एक अशक्त स्ट्रिंग देता है। इसे जोड़कर तय किया गया है ||0, जो अभी भी मेरे समाधान से कम है।
— रिक हिचकॉक
f=क्योंकि केवल आंतरिक समारोह पुनरावर्ती है, curried संस्करण का हिस्सा नहीं है।
— नील
2

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

f⁴L
ŒgÇ€Ṁ

स्पष्टीकरण:

f⁴L
f⁴      -Filter by the character argument.
  L     -Return Length of filtered String.

ŒgÇ€»/
Œg      -Group string by runs of characters.
  ǀ    -Run above function on each group.
    Ṁ   -Return the largest in the list.

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

— DaggerOfMesogrecia
स्रोत
आप के साथ कुछ बाइट्स बचा सकते हैं Œgf€L€Ṁ।
— डेनिस
1

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

import Data.List
((maximum.(0:).map length).).(.group).filter.elem

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

संस्करण पढ़ने के लिए थोड़ा आसान है - पॉइंटफ्री नहीं:

f c s = maximum (0:(map length (filter (elem c) (group s))))

स्ट्रिंग को अक्षर से समूहित करता है, फिर उन समूहों द्वारा फ़िल्टर करता है जिसमें सही वर्ण होता है, फिर लंबाई को पाता है, लंबाई 0 की सूची में संलग्न होता है यदि यह दिखाई नहीं देता है, और अंत में अधिकतम मूल्य पाता है।

— vroomfondel
स्रोत
1

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

(s=Differences[First/@StringPosition[#,#2]];k=t=0;Table[If[s[[i]]==1,t++;If[k<t,k=t],t=0],{i,Length@s}];k+1)&


इनपुट

["xxx xxxx xx", "x"]

— J42161217
स्रोत
1

सीजाम , 20 19 18 16 बाइट्स

0q~e`f{~@=*}$+W=

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

व्याख्या

0                 e# Push 0. We'll need it later.
 q~               e# Read and eval input. Pushes c and s to the stack.
   e`             e# Run-length encode s: turns it into an array of [length, char] pairs.
     f{           e# Map over these pairs using c an extra parameter:
       ~          e#  Dump the pair to the stack.
        @=        e#  Bring c to the top, check equality with the char, pushing 0 or 1.
          *       e#  Multiply the length by the result.
           }      e# (end map)
            $     e# Sort the resulting list in ascending order.
             +    e# Prepend the 0 from before, in case it's empty.
              W=  e# Get the last element.
— बिजनेस कैट
स्रोत
1

एक्सेल, 56 बाइट्स

{=MAX(IFERROR(FIND(REPT(A2,ROW(A:A)),A1)^0*ROW(A:A),0))}

sके लिए इनपुट होना चाहिए A1।
cके लिए इनपुट होना चाहिए A2।
फॉर्मूला एक सरणी सूत्र ( Ctrl+ Shift+ Enter) होना चाहिए जो घुंघराले कोष्ठक जोड़ता है { }।

तकनीकी रूप से, यह केवल वही संभाल सकता है जहां सबसे लंबा रन 1,048,576 (जो कि 2 ^ 20 है) से कम है, क्योंकि वर्तमान एक्सेल की पंक्तियां आपको एक कार्यपत्रक में जाने देंगी। चूँकि यह जब भी पुनरावृत्ति करता है, तो यह स्मृति में मिलियन + मूल्यों को लोड करता है, यह एक उपवास नहीं है फॉर्मूला है।

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

MATL , 15 बाइट्स

0i0v=dfd1L)0hX>

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

बुनियादी एल्गोरिथ्म बहुत ही सरल (विभाजन का कोई उपयोग नहीं!) है, लेकिन मैं में फेंक दिया था 0i0vऔर 0hबढ़त के मामलों के लिए अनुमति देने के लिए। फिर भी, मुझे लगा कि दृष्टिकोण अच्छा था, और शायद मैं अभी भी किनारे के मामलों को संभालने के लिए एक और तकनीक पा सकता हूं: एल्गोरिथ्म एक स्ट्रिंग के बीच में सबसे लंबे समय तक चलने को ठीक पाता है, लेकिन एकल पात्रों या खाली तारों के लिए नहीं; मैं अभी भी परीक्षण कर रहा हूं कि क्या मैं बेहतर परिणामों के लिए बेहतर स्थानों पर चर को 'पैड' कर सकता हूं।

0i0v % Prepends and appends a zero to the (implicit) input.
   = % Element-wise equality with the desired char (implicit input)
   d % Pairwise difference. Results in a 1 at the start of a run, and -1 at the end.
   f % Get indices of 1's and -1's.
   d % Difference to get length of the runs (as well as length of non-runs)
 1L) % Only select runs, throw out non-runs. We now have an array of all run lengths.
  0h % 'Find' (`f`) returns empty if no run is found, so append a zero to the previous array.
  X> % Maximum value.

खाली पर काम नहीं करता c। फिर से, मुझे लगता है कि प्रत्येक स्ट्रिंग में प्रत्येक वर्ण के बीच खाली तार का एक अनंत भाग होता है :)

— Sanchises
स्रोत
1

आर , 66 58 बाइट्स

-8 बाइट्स बीएलटी और मिकी को धन्यवाद 

function(s,c)max((r=rle(el(strsplit(s,''))))$l*(r$v==c),0)

एक अनाम फ़ंक्शन देता है। TIO में 1-बाइट अंतर है क्योंकि elवहाँ अक्षम्य कारणों से काम नहीं करता है।

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

— ग्यूसेप
स्रोत
एक बाइट के साथ सहेजेंr=rle(el(strsplit(s,'')))
— BLT
1
अगर आपने इसे देखा तो मेरी पिछली टिप्पणी को अनदेखा करें। आपके लिए बेहतर हैfunction(s,c)max((r=rle(el(strsplit(s,''))))$l*(r$v==c),0)
— मिकी
@BLT elTIO पर काम नहीं करता है (पता नहीं क्यों) और मैंने अभी-अभी कॉपी की है और इसे वहां काम करने वाले कोड से चिपकाया है, इसलिए मुझे याद रखना होगा कि यह बहुत ही चालाक है! धन्यवाद!
— ग्यूसेप
1

जावा 8, 67 65 बाइट्स

s->c->{int t=0,m=0;for(char x:s)m=m>(t=x==c?t+1:0)?m:t;return m;}

-2 बाइट्स धन्यवाद @ ओलिवियरग्रेगायर के

sएक char[], और के रूप में इनपुट लेता हैc हैchar

स्पष्टीकरण:

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

s->c->{          // Method with char[] and char parameters and int return-type
  int t=0,       //  Temp counter-integer
      m=0;       //  Max integer
  for(char a:s)  //  Loop over the characters of the input
    m=m>(
     t=x==c?     //   If the current character equals the input-character:
      t+1        //    Raise `t` by 1
      :          //   Else:
       0)        //    Reset `t` to 0
    ?m:t;        //   If `t` is now larger than `m`, put `t` as new max into `m`
                 //  End of loop (implicit / single-line body)
  return m;      //  Return the resulting max
}                // End of method
— केविन क्रूज़सेन
स्रोत
1
m=m>(t=x==c?t+1:0)?m:t;से छोटा है {t=x==c?t+1:0;m=m>t?m:t;}।
— ओलिवियर ग्रेगोइरे
भले ही यह अधिक लंबा है, मुझे अपना पहला विचार पसंद है s->c->java.util.Arrays.stream(s.split("[^"+c+"]")).mapToInt(z->z.length()).max().orElse(0):;)
— ओलिवियर ग्रेजायर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.