29

मान लें कि हमारे पास एक स्ट्रिंग है, और हम हर अक्षर के अधिकतम दोहराया अनुक्रम को ढूंढना चाहते हैं।

उदाहरण के लिए, नमूना इनपुट दिया गया:

"acbaabbbaaaaacc"

नमूना इनपुट के लिए आउटपुट हो सकता है:

a=5
c=2
b=3

नियम:

आपका कोड फ़ंक्शन या प्रोग्राम हो सकता है - आपके लिए चुनने के लिए
इनपुट स्टड, फ़ाइल या फ़ंक्शन पैरामीटर द्वारा हो सकता है
आउटपुट में केवल वर्ण शामिल होने चाहिए जो इनपुट में दिखाई देते हैं
इनपुट अधिकतम लंबाई 1024 है
आउटपुट ऑर्डर मायने नहीं रखता है, लेकिन इसे [char] = [अधिकतम दोहराया अनुक्रम] [सीमांकक] के रूप में प्रिंट करना होगा
स्ट्रिंग में कोई भी वर्ण हो सकता है

प्रतियोगिता गुरुवार 3 फरवरी को 23:59 यूटीसी पर समाप्त होती है।

code-golf

— yossico
स्रोत

क्या इनपुट स्ट्रिंग की लंबाई अधिकतम है?

— सिग्मा

2

क्या आउटपुट को बिल्कुल दिया जाना चाहिए? क्या हम उन पत्रों के लिए 0 कह सकते हैं जो प्रकट नहीं होते हैं? क्या उच्चतम पत्र तक प्रत्येक अक्षर कम से कम एक बार दिखाई देगा?

— xnor

1

कृपया स्पष्ट करें कि क्या आउटपुट को आपके प्रश्न में उदाहरण के रूप में स्वरूपित किया जाना है। वर्तमान 16 उत्तरों में से कम से कम 10 उत्तर एक अलग प्रारूप का उपयोग करते हैं, तीन अन्य दो अलग-अलग संस्करण प्रस्तुत करते हैं।

— डेनिस

1

@ जॉय आपको शायद गोल्फ के लिए दंडित करना चाहिए। आप इसे संघनित करके, मैं l:S_&{'=L{2$+_S\#)}g,(N}/उत्पादन प्रणालियों में देखने जा रहा हूँ ! और मैं तुम्हारे नाम का श्राप दूंगा।

— क्रंचर

1

क्या यह गिनती है? :) wolframalpha.com/input/?i=char+%22acbaabbbaaaaacc%22+frequency

— Juned

22

8086 मशीन कोड, 82 80

x.comफ़ाइल की सामग्री :

B7 3D 89 DF B1 80 F3 AA 0D 0A 24 B4 01 CD 21 42
38 D8 74 F7 38 17 77 02 88 17 88 C3 31 D2 3C 0D
75 E9 BF 21 3D B1 5E 31 C0 F3 AE E3 EE 4F BB 04
01 8A 05 D4 0A 86 E0 0D 30 30 89 47 02 3C 30 77
04 88 67 03 43 89 3F 89 DA B4 09 CD 21 47 EB D7

यह केवल 99 वर्णों तक की पुनरावृत्ति का समर्थन करता है।

स्रोत कोड ( debug.comकोडांतरक के लिए इनपुट के रूप में सेवा ), टिप्पणियों के साथ!

a
    mov bh, 3d         ; storage of 128 bytes at address 3d00
    mov di, bx
    mov cl, 80
    rep stosb          ; zero the array
    db 0d 0a 24
; 10b
    mov ah, 1
    int 21             ; input a char
    inc dx             ; calculate the run length
    cmp al, bl         ; is it a repeated character?
    je  10b
    cmp [bx], dl       ; is the new run length greater than previous?
    ja  11a
    mov [bx], dl       ; store the new run length
; 11a
    mov bl, al         ; remember current repeating character
    xor dx, dx         ; initialize run length to 0
    cmp al, d          ; end of input?
    jne 10b            ; no - repeat
    mov di, 3d21       ; start printing run lengths with char 21
    mov cl, 5e         ; num of iterations = num of printable characters
; 127
    xor ax, ax
    repe scasb         ; look for a nonzero run length
    jcxz 11b           ; no nonzero length - exit
    dec di
    mov bx, 104        ; address of output string
    mov al, [di]       ; read the run length
    aam                ; convert to decimal
    xchg al, ah
    or  ax, 3030
    mov [bx+2], ax
    cmp al, 30         ; was it less than 10?
    ja  145
    mov [bx+3], ah     ; output only one digit
    inc bx             ; adjust for shorter string
; 145
    mov [bx], di       ; store "x=" into output string
    mov dx, bx         ; print it
    mov ah, 9
    int 21
    inc di
    jmp 127            ; repeat
; 150

rcx 50
n my.com
w
q

यहाँ कुछ गोल्फ तकनीक का उपयोग किया गया है जो मुझे लगता है कि मज़ेदार थे:

सरणी का पता है 3d00, जहां 3dके लिए एएससीआई-कोड है =। इस तरह, चरित्र के लिए सरणी के प्रवेश का पता xहै 3d78। जब 2-वर्ण स्ट्रिंग के रूप में व्याख्या की जाती है, तो यह है x=।
आउटपुट बफर पते पर है 104; यह आरंभीकरण कोड को अधिलेखित करता है जिसकी अब आवश्यकता नहीं है। एंड-ऑफ-लाइन अनुक्रम 0D 0A 24हानिरहित कोड के रूप में निष्पादित किया जाता है।
यहाँ aamनिर्देश किसी भी गोल्फिंग प्रदान नहीं करता है, हालांकि यह कर सकता है ...
संख्या को दो बार लिखना, पहले यह मान लेना कि यह 10 से अधिक है, और फिर छोटा होने पर इसे सही करना।
एक्ज़िट निर्देश एक अस्पष्ट पते पर है 11b, जिसमें C3भाग्य द्वारा आवश्यक मशीन कोड शामिल है।

— anatolyg
स्रोत

दिलचस्प दृष्टिकोण। हालाँकि, 99 पुनरावृत्तियों की सीमा के साथ, यह उन मामलों को नहीं संभाल पाएगा जहाँ 1024 आसा के इनपुट की आपूर्ति की जाती है।

— होमर 6

14

सीजेएम, 27 26 25 बाइट्स

l:S_&{'=L{2$+_S\#)}g,(N}/

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

उदाहरण

$ cjam maxseq.cjam <<< "acbaabbbaaaaacc"
a=5
c=2
b=3

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

l:S       " Read one line from STDIN and store the result in “S”.                   ";
_&        " Intersect the string with itself to remove duplicate characters.        ";
{         " For each unique character “C” in “S”:                                   ";
  '=L     " Push '=' and ''.                                                        ";
  {       "                                                                         ";
    2$+_  " Append “C” and duplicate.                                               ";
    S\#)  " Get the index of the modified string in “S” and increment it.           ";
  }g      " If the result is positive, there is a match; repeat the loop.           ";
  ,       " Retrieve the length of the string.                                      ";
  (       " Decrement to obtain the highest value that did result in a match.       ";
  N       " Push a linefeed.                                                        ";
}/        "                                                                         ";

— डेनिस
स्रोत

9

जे - 52 बाइट्स

खैर, फिर से एक सरल दृष्टिकोण।

f=:([,'=',m=:":@<:@#@[`(]m~[,{.@[)@.(+./@E.))"0 1~~.

स्पष्टीकरण:

f=:([,'=',m=:":@<:@#@[`(]m~[,{.@[)@.(+./@E.))"0 1~~.
                                                 ~~. Create a set of the input and apply it as the left argument to the following.
   ([,'=',m=:":@<:@#@[`(]m~[,{.@[)@.(+./@E.))"0 1    The function that does the work
                                             "0 1    Apply every element from the left argument (letters) with the whole right argument (text).
                                  @.(+./@E.)         Check if the left string is in right string.
                       (]m~[,{.@[)                   If yes, add one letter to the left string and recurse.
             ":@<:@#@[                               If not, return (length of the left string - 1), stringified.
    [,'=',                                           Append it to the letter + '='

उदाहरण:

   f 'acbaabbbaaaaacc'
a=5
c=2
b=3
   f 'aaaabaa'
a=4
b=1

यदि फ्री-फॉर्म आउटपुट की अनुमति है (कई अन्य उत्तरों में), तो मेरे पास 45 बाइट्स संस्करण भी हैं। ये बॉक्स बॉक्स की एक सूची का प्रतिनिधित्व करते हैं (हां, वे इस तरह मुद्रित होते हैं, हालांकि एसई की लाइन-ऊंचाई उन्हें तोड़ती है)।

   f=:([;m=:<:@#@[`(]m~[,{.@[)@.(+./@E.))"0 1~~.
   f 'acbaabbbaaaaacc'
┌─┬─┐
│a│5│
├─┼─┤
│c│2│
├─┼─┤
│b│3│
└─┴─┘
   f 'aaaabaabba'
┌─┬─┐
│a│4│
├─┼─┤
│b│2│
└─┴─┘

— seequ
स्रोत

8

रूबी, ,२

(a=$*[0]).chars.uniq.map{|b|puts [b,a.scan(/#{b}+/).map(&:size).max]*?=}

यह कमांड लाइन तर्कों और आउटपुट से stdout तक इनपुट लेता है।

— afuous
स्रोत

charsसे थोड़ा छोटा है split("")।

— वेंचरो

@Ventero मैंने कोशिश की, लेकिन charsएक सरणी के बजाय एक एन्यूमरेटर देता है। मैं 1.9.3 में हूं, तो क्या यह 2.0 की बात है?

— afuous

हाँ, 2.0 में charsएक सरणी देता है।

— वेंचरो

यह नियमों को थोड़ा लंबा खींच सकता है, लेकिन शायद pइसके बजाय उपयोग करें puts?

— शेल्वकु

1

समझा। यद्यपि यह इसे कम सुंदर बनाता है, मैं यह नहीं देख सकता कि यह किसी भी नियम को तोड़ देगा।

— डानिएरो

7

GolfScript, 26 बाइट्स

:s.&{61{2$=}s%1,/$-1=,n+}%

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

स्पष्टीकरण:

:ssबाद में उपयोग के लिए चर में इनपुट स्ट्रिंग बचाता है ।
.&इनपुट में अद्वितीय वर्णों को निकालता है, जो बाकी कोड को { }%लूप में रखता है।
61 स्टैक पर वर्तमान चरित्र के शीर्ष पर संख्या 61 (एएससीआईआई कोड एक समान चिह्न के लिए) को धक्का देता है, एक आउटपुट सीमांकक के रूप में कार्य करने के लिए।
{2$=}s%स्ट्रिंग लेता है sऔर अपने वर्णों को 1 से बदल देता है यदि वे वर्तमान वर्ण के बराबर हो रहे हैं, या 0 यदि वे नहीं करते हैं। (यह आउटपुट के लिए स्टैक पर करंट कैरेक्टर को भी छोड़ता है।)
1,/ लोगों और शून्य का यह तार लेता है, और इसे शून्य पर विभाजित करता है।
$परिणामस्वरूप सबस्ट्रिंग को सॉर्ट करता है, -1=अंतिम सबस्ट्रिंग को निकालता है (जो, क्योंकि वे सभी एक ही वर्ण के दोहराव से मिलकर बने हैं, सबसे लंबा है), और ,इस सबस्ट्रिंग की लंबाई लौटाता है।
n+ लंबाई को बढ़ाता है और इसके लिए एक नई रूपरेखा जोड़ता है।

Ps। यदि आउटपुट में बराबर चिह्न वैकल्पिक हैं, तो 24 बाइट की कुल लंबाई के लिए 61छोड़ा जा सकता है (और उसके 2$द्वारा प्रतिस्थापित 1$) :

:s.&{{1$=}s%1,/$-1=,n+}%

— इल्मरी करोनें
स्रोत

1

आप स्वैप को बचा सकते हैं यदि आप 61पहले धक्का देते हैं :s.&{61{2$=}s%1,/$-1=,n+}%:।

— हावर्ड

@ हॉवर्ड: धन्यवाद!

— इल्मरी करोनें

6

कॉफ़ीस्क्रिप्ट, 109 बाइट्स

मुझे रेगेक्स पसंद है।

f=(s)->a={};a[t[0]]=t.length for t in s.match(/((.)\2*)(?!.*\1)/g).reverse();(k+'='+v for k,v of a).join '\n'

यहां संकलित जावास्क्रिप्ट है जिसे आप अपने ब्राउज़र के कंसोल में आज़मा सकते हैं

f = function(s) {
  var a, t, _i, _len, _ref;
  a = {};
  _ref = s.match(/((.)\2*)(?!.*\1)/g).reverse();
  for (_i = 0, _len = _ref.length; _i < _len; _i++) {
    t = _ref[_i];
    a[t[0]] = t.length;
  }
  return a;
};

तब आप कॉल कर सकते हैं

f("acbaabbbaaaaacc")

लेना

c=2
a=5
b=3

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

यह इनपुट के लिए गलत परिणाम उत्पन्न करने लगता है aaaabaa।

— वेंतोरो

@ वेंटरो आप सही कह रहे हैं, दो समस्याएं हैं। एक आसानी से तय हो गया है, लेकिन मुझे दूसरे के बारे में सोचने की जरूरत है।

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

@Ventero तय की।

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

5

पायथ , 24 25 26 (या 29)

=ZwFY{Z=bkW'bZ~bY)p(Yltb

यहां टेस्ट किया जा सकता है: लिंक

प्रारूप में आउटपुट:

('a', 5)
('c', 2)
('b', 3)

स्पष्टीकरण:

=Zw              Store one line of stdin in Z
FY{Z             For Y in set(Z):
=bk              b=''
W'bZ             while b in Z:
~bY              b+=Y
)                end while
p(Yltb           print (Y, len(b)-1)

अजगर:

k=""
Z=copy(input())
for Y in set(Z):
 b=copy(k)
 while (b in Z):
  b+=Y
 print(_tuple(Y,len(tail(b))))

उचित (a = 5) आउटपुट के लिए, उपयोग करें:

=ZwFY{Z=bkW'bZ~bY)p++Y"="`ltb

29 अक्षर

— isaacg
स्रोत

लगता है कि आप एक ही विचार था। उसके लिए एक +1 है।

— २१

@ हाँ, यह ऐसा करने का एक बहुत अच्छा तरीका है।

— isaacg

वास्तव में आपके एल्गोरिथ्म से संबंधित नहीं है, लेकिन अजगर आउटपुट भ्रामक है, क्योंकि k=''कहीं और परिभाषित किया गया है।

— 22

हाँ, इसके बारे में क्षमा करें। मैं इसे सुधारने पर काम करूंगा। मैं इसे भी संपादित करूँगा।

— इसहाक

5

सी, 126 125 119 बाइट्स

l,n,c[256];main(p){while(~(p=getchar()))n*=p==l,c[l=p]=c[p]>++n?c[p]:n;for(l=256;--l;)c[l]&&printf("%c=%d\n",l,c[l]);}

चल रहा है:

$ gcc seq.c 2>& /dev/null
$ echo -n 'acbaabbbaaaaacc' | ./a.out
c=2
b=3
a=5

— शराबी
स्रोत

आप इस उत्तरgetchar()>0 को ~getchar()पसंद कर सकते हैं

— एनाटॉलीग

@anatolyg क्या EOF को वास्तव में -1 होने की गारंटी है? मुझे लगा कि यह केवल विशेष रूप से परिभाषित किया जा रहा है <0।

— शराबी

मुझे लगता है कि -1 काफी सामान्य है (यानी विंडोज और लिनक्स) ताकि आप इसे कोड गोल्फ के लिए मान सकें। उत्पादन कोड के लिए, less than zeroपूरी तरह से ठीक है, लेकिन == EOFअधिक स्पष्ट है।

— अनातोली

@anatolyg ज़रूर, और वास्तव में मैं कल्पना EOF जाहिरा तौर पर भी <0 होने की गारंटी नहीं है प्रति लगता है - यह हो सकता है यह भी हो सकता है, उदाहरण के लिए, 256 मैं सिर्फ एक बाइट को सहेज लेंगे ताकि। :)

— शराबी

2

EOFनकारात्मक होने की गारंटी है, और charहस्ताक्षर किए जाने पर भी -1 का उपयोग किया जाता है; यहाँ

— अनातोलीग

4

गणितज्ञ , 69४ 74२ ६ ९

Print[#[[1,1]],"=",Max[Tr/@(#^0)]]&/@Split@Characters@#~GatherBy~Max&

% @ "acbaabbbaaaaacc"

a=5
c=2
b=3

बहुत अच्छा नहीं है लेकिन स्ट्रिंग्स मैथमेटिका का सबसे अच्छा क्षेत्र नहीं हैं। हालांकि बेहतर हो रही है। :-)

— Mr.Wizard
स्रोत

यह बहुत प्रभावशाली गोल्फिंग है (यह खुद को

— आजमाने के

v10, पूर्ण समाधान नहीं: First@*MaximalBy[Length] /@ GroupBy[First]@Split@Characters[#] & कम से कम यह बहुत सीधा और पठनीय है।

— शेजोलक्स

@Szabolcs धन्यवाद! बीच क्या अंतर है GroupByऔर GatherBy?

— श्री। छिपकली २ Mr

मुख्य अंतर यह है कि GroupByरिटर्न ए Association। मैंने अन्य अंतरों का विस्तार से अध्ययन नहीं किया है। reference.wolfram.com/language/ref/GroupBy.html आप इसे एक मुफ़्त खाते के साथ क्लाउड में आज़मा सकते हैं (यह है कि मैं इनसे कैसे खेल रहा हूं)।

— शैबॉलेक्स

3

सी # (लिनक्यूपैड)

146

यह tsavino का उत्तर है लेकिन छोटा है। यहाँ, मैं के Distinct()बजाय इस्तेमाल किया GroupBy(c=>c)। इसके अलावा घुंघराले ब्रेसिज़ foreach-loopबाहर छोड़ दिए जाते हैं:

void v(string i){foreach(var c in i.Distinct())Console.WriteLine(c+"="+(from Match m in Regex.Matches(i,"["+c+"]+")select m.Value.Length).Max());}

136

मैंने lambda expressionसामान्य क्वेरी सिंटैक्स के बजाय का उपयोग करने की कोशिश की, लेकिन जब से मुझे Cast<Match>पहली ज़रूरत थी , कोड 1 वर्ण लंबा हो गया ... किसी भी तरह, चूंकि इसे LinQPad में निष्पादित किया जा सकता है, आप Dump()इसके बजाय उपयोग कर सकते हैं Console.WriteLine():

void v(string i){foreach(var c in i.Distinct())(c+"="+(from Match m in Regex.Matches(i,"["+c+"]+")select m.Value.Length).Max()).Dump();}

कोड के आगे के अध्ययन ने मुझे इस बारे में सोचने पर मजबूर कर दिया Max()। यह फ़ंक्शन भी स्वीकार करता है Func। इस तरह मैं Selectलैम्ब्डा एपेक्स्रेशन का उपयोग करते समय भाग को छोड़ सकता है :

void v(string i){foreach(var c in i.Distinct())(c+"="+Regex.Matches(i,"["+c+"]+").Cast<Match>().Max(m=>m.Value.Length)).Dump();}

इस प्रकार, अंतिम परिणाम:

128

अद्यतन करें:

डैन पूज़ी से टिप के लिए धन्यवाद, मैं एक और 6 पात्रों को बचाने में सक्षम था:

void v(string i){i.Distinct().Select(c=>c+"="+Regex.Matches(i,"["+c+"]+").Cast<Match>().Max(m=>m‌.Value.Length)).Dump();}

लंबाई:

122

— अब्बास
स्रोत

आपके सुधारों के लिए धन्यवाद, मुझे LinqPad में .Dump () के साथ चाल के बारे में पता नहीं था। ईमानदार होने के लिए, मैंने विज़ुअल स्टूडियो में कोड विकसित किया और कुछ वर्णों को बचाने के लिए इसे LinqPad में कॉपी किया क्योंकि LinqPad को एक मुख्य विधि की आवश्यकता नहीं है।

— tsavinho 12

धन्यवाद! मुझे भी Dump()हाल ही में विधि का पता चला है , हर बार आपको 10+ चार्ट बचाता है :) घुंघराले ब्रेसिज़ आसान थे और बाकी सब थोड़ा दिमाग लगाने वाला था: डी

— अब्बास

1

यदि आप LinqPad की IEnumerableप्रदर्शन शैली का उपयोग करके खुश हैं तो आप अपने शरीर के साथ एक और 8 वर्णों को बचा सकते हैं:i.Distinct().Select(c=>c+"="+Regex.Matches(i,"["+c+"]+").Cast<Match>().Max(m=>m.Value.Length)).Dump();

— Dan Puzey

3

पायथन 3 (70)

s=input()
for c in set(s):
 i=1
 while c*i in s:i+=1
 print(c,'=',i-1)

यहां तक कि गोल्फ पाइथन बहुत पठनीय हो सकता है। मुझे लगता है कि यह कोड सिंगल-लेटर वैरिएबल और लूप होते हुए वन-लाइन को छोड़कर पूरी तरह से मुहावरेदार है।

उदाहरण चलता है:

>>> helloworld
e = 1
d = 1
h = 1
l = 2
o = 1
r = 1
w = 1
>>> acbaabbbaaaaacc
a = 5
c = 2
b = 3

— XNOR
स्रोत

यह एक दिलचस्प समाधान है

— क्रंचर

1

यदि आप सेट को बदल देते हैं तो मुझे लगता है कि यह अभी भी आवश्यकताओं को पूरा करता है। कहीं भी यह नहीं कहा गया है कि प्रत्येक वर्ण को केवल एक बार मुद्रित किया जाना चाहिए।

— क्रंचर

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

— xnor

2

रूबी, ५ Rub

h={}
gets.scan(/(.)\1*/){h[$1]=[h[$1]||0,$&.size].max}
p h

STDIN से इनपुट लेता है, इसे फॉर्म में STDOUT में आउटपुट करता है {"a"=>5, "c"=>2, "b"=>3}

— histocrat
स्रोत

2

LINQPad में C # - 159 बाइट्स

ठीक है, कम से कम मैंने टी-एसक्यूएल को हराया; पी किसी और को नहीं हराएगा, लेकिन मुझे लगा कि मैं इसे वैसे भी साझा करूंगा।

void v(string i){foreach(var c in i.GroupBy(c=>c)){Console.WriteLine(c.Key+"="+(from Match m in Regex.Matches(i,"["+c.Key+"]+")select m.Value.Length).Max());}}

उपयोग:

v("acbaabbbaaaaacc");

सुझावों का हमेशा स्वागत है!

— tsavinho
स्रोत

बहुत बढ़िया जवाब! मुझे कुछ सुझाव मिले हैं, लेकिन यह एक टिप्पणी के लिए बहुत लंबा था इसलिए मेरे उत्तर के लिए यहां क्लिक करें । :)

— अब्बास

2

पॉवरशेल 80 77 72

$x=$args;[char[]]"$x"|sort -u|%{"$_="+($x-split"[^$_]"|sort)[-1].length}

आपको इसे कंसोल पर चलाने की आवश्यकता है ...

— DarkAjax
स्रोत

1

$xशानदार है। आप तीन बाइट का उपयोग नहीं कर रहे हैं। भी sort -uसहता है। पूर्ण पैरामीटर नामों की वर्तनी की आवश्यकता शायद ही हो। हालाँकि, यह regex में अनपेक्षित उपयोग के कारण कुछ वर्णों के लिए विफल हो जाएगा। इस बात पर निर्भर करता है कि »स्ट्रिंग में किसी भी वर्ण को शामिल किया जा सकता है« इसे समझा जाना चाहिए, यह एक समस्या हो सकती है।

— जॉय

@Joey टिप के लिए धन्यवाद सॉर्ट पर, हालांकि $ x के बारे में मैं इसे काम करने के लिए नहीं मिला [char[]]"$args"|sort -u|%{"$_="+($args-split"[^$_]"|sort)[-1].length}, ऐसा लगता है कि दूसरा $ args खाली आता है ... - Darkajax 17 मिनट पहले

— DarkAjax

हाँ, हाँ। माफ़ कीजिये। ऐसा इसलिए है क्योंकि यह एक स्क्रिप्ट ब्लॉक में है, जिसके अपने तर्क हैं ( $argsअब स्क्रिप्ट का एक भी नहीं है)।

— जॉय

2

पर्ल - 65 71 76 वर्ण

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

प्रत्येक उत्तर के लिए, golf.pl पर कॉपी करें और निम्नानुसार चलाएँ:

echo acbaabbbaaaaacc | perl golf.pl

मेरा सबसे छोटा समाधान प्रत्येक चरित्र को जितनी बार प्रकट होता है, उतनी बार प्रिंट करता है, क्योंकि यह नियमों द्वारा निषिद्ध नहीं है।

$_=$i=<>;for(/./g){$l=length((sort$i=~/$_*/g)[-1]);print"$_=$l
"}

मेरा अगला-सबसे छोटा समाधान (85 90 वर्ण) केवल प्रत्येक वर्ण को एक बार प्रिंट करता है:

<>=~s/((.)\2*)(?{$l=length$1;$h{$2}=$l if$l>$h{$2}})//rg;print"$_=$h{$_}
"for keys %h

— केजेपी
स्रोत

1

एफ # - 106

let f s=
 let m=ref(Map.ofList[for c in 'a'..'z'->c,0])
 String.iter(fun c->m:=(!m).Add(c,(!m).[c]+1))s;m

FSI में, कॉलिंग

f "acbaabbbaaaaacc"

देता है

val it : Map<char,int> ref =
  {contents =
    map
      [('a', 8); ('b', 4); ('c', 3); ('d', 0); ('e', 0); ('f', 0); ('g', 0);
       ('h', 0); ('i', 0); ...];}

हालाँकि, अतिरिक्त जानकारी के बिना इसे प्रिंट करने के लिए, इसे इस तरह से कॉल करें:

f "acbaabbbaaaaacc" |> (!) |> Map.filter (fun _ n -> n > 0)

जो देता है

val it : Map<char,int> = map [('a', 8); ('b', 4); ('c', 3)]

— Jwosty
स्रोत

1

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

y=x=prompt();while(y)r=RegExp(y[0]+'+','g'),alert(y[0]+'='+x.match(r).sort().reverse()[0].length),y=y.replace(r,'')

नमूना उत्पादन:

lollolllollollllollolllooollo
l=4
o=3

acbaabbbaaaaacc
a=5
c=2
b=3

helloworld
h=1
e=1
l=2
o=1
w=1
r=1
d=1

— Дамян Станчев
स्रोत

1

टी-एसक्यूएल (2012) 189 171

संपादित करें: हटाया गया ORDER BYक्योंकि नियम किसी भी आउटपुट आदेश की अनुमति देते हैं।

एक CHAR चर से इनपुट लेता है @a, और स्ट्रिंग में प्रत्येक वर्ण के लिए एक पंक्ति बनाने के लिए और अनुक्रमिक घटनाओं का पता लगाने के लिए एक पुनरावर्ती CTE का उपयोग करता है ।

उसके बाद, यह आउटपुट के आदेश के लिए एक सरल SELECTऔर GROUP BYविचार के साथ है।

SQL Fiddle पर इसे आज़माएं ।

WITH x AS(
    SELECT @a i,''c,''d,0r,1n
    UNION ALL 
    SELECT i,SUBSTRING(i,n,1),c,IIF(d=c,r+1,1),n+1
    FROM x
    WHERE n<LEN(i)+2
)
SELECT d+'='+LTRIM(MAX(r))
FROM x
WHERE n>2
GROUP BY d

चर सौंपना:

DECLARE @a CHAR(99) = 'acbaabbbaaaaacc';

नमूना उत्पादन:

a=5
c=2
b=3

— comfortablydrei
स्रोत

मुझे नहीं लगता कि मैंने पहले यहां एसक्यूएल समाधान देखा है। दिलचस्प।

— सेरिया

के strबजाय कार्य पर विचार करें ltrim। आप @एक चर को बचाने के लिए अपने चर का नाम भी दे सकते हैं । यह आपको iआरकेटी में चर को खोने की अनुमति देता है । मुझे लगता है कि आप इस तरह से काफी कुछ शेव कर सकते हैं। आप पहले से पंक्तियों या अंतराल से अधिक राशि जैसे विंडोिंग फ़ंक्शन का उपयोग करके क्वेरी को फिर से लिखने में सक्षम हो सकते हैं। मैंने अभी तक आप का मन नहीं बनाया है।

— माइकल बी

@MichaelB सलाह के लिए धन्यवाद। मेरे पास स्ट्रैस () के साथ जो परेशानी है वह यह है कि यह अतिरिक्त स्थानों का एक गुच्छा उत्पन्न करता है। मैं निश्चित रूप से @ एक चर के रूप में उपयोग करना शुरू करूँगा!

— आराम

यह सच है कि strहमेशा 10 वर्णों का आउटपुट होता है, लेकिन यह गोल्फिंग है: पी

— माइकल बी

1

हास्केल - 113 120 बाइट्स

import Data.List
main=interact$show.map(\s@(c:_)->(c,length s)).sort.nubBy(\(a:_)(b:_)->a==b).reverse.sort.group

के साथ परीक्षण किया गया

$ printf "acbaabbbaaaaacc" | ./sl
[('a',5),('b',3),('c',2)]

— gxtaillon
स्रोत

आप .लंबोदा बनाने से बचने के लिए (कंपोज़) फ़ंक्शन का उपयोग कर सकते हैं जहां पैरामीटर केवल $जुड़े कार्यों की श्रृंखला के अंत के बाद दिखाई देता है । ऐसा करने के लिए, बस सभी $s को .s में बदलें (उदाहरण:: में (\i->reverse$sort$group i)बदल जाता है reverse.sort.group।

— YawarRaza7349

1

जावास्क्रिप्ट [83 बाइट्स]

prompt().match(/(.)\1*/g).sort().reduce(function(a,b){return a[b[0]]=b.length,a},{})

^{इस कोड को ब्राउजर कंसोल में चलाएं।}

इनपुट के लिए " acbaabbbaaaaacc" कंसोल को आउटपुट होना चाहिए " Object {a: 5, b: 3, c: 2}"।

— दृष्टि
स्रोत

1

जावास्क्रिप्ट - 91

for(i=0,s=(t=prompt()).match(/(.)\1*/g);c=s[i++];)t.match(c+c[0])||alert(c[0]+'='+c.length)

संपादित करें: मेरा पहला समाधान नियमों का पालन करता है, लेकिन यह कई बार एकल चार घटनाओं को प्रिंट करता है जैसे abab=> a=1,b=1,a=1,b=1इसलिए मैं इसके साथ आया ( 101 वर्ण), उन लोगों के लिए जो मेरे पहले एक से संतुष्ट नहीं थे:

for(i=0,s=(t=prompt()).match(/((.)\2*)(?!.*\1)/g);c=s[i++];)t.match(c+c[0])||alert(c[0]+'='+c.length)

— core1024
स्रोत

0

जूलिया, 85

f(s)=(l=0;n=1;a=Dict();[c==l?n+=1:(n>get(a,l,1)&&(a[l]=n);n=1;l=c) for c in s*" "];a)
julia> f("acbaabbbaaaaacc")
{'a'=>5,'c'=>2,'b'=>3}

— gggg
स्रोत

0

पायथन 3 - 111, 126, 115 114 111 बाइट्स

निष्पादन योग्य कोड जो 1 पंक्ति पढ़ेगा (केवल लोअरकेस अक्षर az का उपयोग करें)

d={}.fromkeys(map(chr,range(97,123)),0)
for c in input():d[c]+=1
[print("%s=%d"%(p,d[p]))for p in d if d[p]>0]

संपादित करें: @Therare से अनुरोध पर अनावश्यक उत्पादन को छोड़कर

आउटपुट अच्छा लग रहा है

~/codegolf $ python3 maxseq.py 
helloworld
l=3
o=2
h=1
e=1
d=1
w=1
r=1

— कुत्ता बिल्ली की दुनिया खाता है
स्रोत

आपको वास्तव में अनावश्यक आउटपुट को बाहर करना चाहिए। (मुझे लगता है)

— देखिए

"फिक्स्ड" आउटपुट

— कुत्ता बिल्ली दुनिया

आप ब्रेसिज़, संख्या और कीवर्ड, जैसे forया के बीच रिक्त स्थान निकाल सकते हैं if।

— देखिए

3

मुझे लगता है कि आपने सवालों को गलत बताया है। l=2और o=1"

— हेलोवर्ल्ड

4

आप अधिकतम लगातार दिखावे के बजाय कुल दिखावे की गिनती कर रहे हैं।

— 22

0

जावास्क्रिप्ट - 141 137 125

मुझे रेगेक्स पसंद नहीं है :)

function g(a){i=o=[],a=a.split('');for(s=1;i<a.length;){l=a[i++];if(b=l==a[i])s++;if(!b|!i){o[l]=o[l]>s?o[l]:s;s=1}}return o}

रन

console.log(g("acbaabbbaaaaacc"));

आउटपुट

[ c: 2, a: 5, b: 3 ]

— मैट
स्रोत

0

जावास्क्रिप्ट, 109 104 100 98 बाइट्स

function c(s){q=l={};s.split('').map(function(k){q[k]=Math.max(n=k==l?n+1:1,q[l=k]|0)});return q}

उदाहरण का उपयोग:

console.log(c("aaaaaddfffabbbbdb"))

आउटपुट:

{ a: 5, d: 2, f: 3, b: 4 }

— शराबी
स्रोत

0

PHP, 104 102 96

<?php function _($s){while($n=$s[$i++]){$a[$n]=max($a[$n],$n!=$s[$i-2]?$v=1:++$v);}print_r($a);}

प्रयोग

_('asdaaaadddscc');

मुद्रित

Array ( [a] => 4 [s] => 1 [d] => 3 [c] => 2 )

— lastbyte
स्रोत

0

जावा 247

import java.util.*;public class a{public static void main(String[]a){Map<Character, Integer> m = new HashMap<>();for(char c:a[0].toCharArray()){Integer v=m.get(c);m.put(c,v==null?1:v+1);}for(char c:m.keySet())System.out.println(c+"="+m.get(c));}}

— user902383
स्रोत

import java.util.*;जावा में काम करता है ?

— देखिए

हां और मैं पुराने कोड

— user902383

ओपी ने कहा कि यह केवल एक फ़ंक्शन / विधि हो सकती है ताकि आप इसे केवल विधि के लिए छोटा कर सकें।

— रुडी करशव

यह स्ट्रिंग में चरित्र की सभी घटनाओं को आउटपुट करता है, न कि चरित्र के सबसे लंबे सब्सट्रिंग्स को। उदाहरण के लिए, acbaabbbaaaaaccआउटपुट के a=8; b=4; c=3बजाय a=5; b=3; c=2।

— केविन क्रूज़सेन

0

सी 169

ASCII तालिका में प्रत्येक मुद्रण योग्य वर्ण को Iterates और इनपुट स्ट्रिंग से अधिकतम गिना जाता है।

#define N 128
int c,i,n;
char Y[N],*p;
int main(){gets(Y);
for(c=33;c<127;c++){p=Y;n=0,i=0;while(*p){if(*p==c){i++;}else{n=(i>n)?i:n;i=0;}p++;}
if(n>0) printf("%c=%d\n",c,n);}
}

— bacchusbeale
स्रोत

क्या आपने इसका परीक्षण किया है? ऐसा नहीं लगता है कि यह बहुत सारे तारों पर सही आउटपुट पैदा करता है, और यह उस युक्ति को भी पूरा नहीं करता है जो कहती है कि इनपुट 1024 लंबे तक हो सकता है ... साथ ही, इसमें बहुत से आसान गोल्फ तकनीक हैं चुक गया। :)

— शराबी

0

जावास्क्रिप्ट 116

prompt(x={}).replace(/(.)\1*/g,function(m,l){n=m.length
if(!x[l]||x[l]<n)x[l]=n})
for(k in x)console.log(k+'='+x[k])

— wolfhammer
स्रोत

0

ग्रूवी - 80 वर्ण

Xnor द्वारा इस चतुर उत्तर के आधार पर :

t=args[0];t.toSet().each{i=0;
while(t.contains(it*++i));
println "${it}=${i-1}"}

आउटपुट:

$ groovy Golf.groovy abbcccdddd
d=4
b=2
c=3
a=1

Ungolfed:

t=args[0]

t.toSet().each { c ->
    i=0
    s=c

    // repeat the char c with length i
    // e.g. "b", "bb", "bbb", etc
    // stop when we find a length that is not in t:
    // this is the max + 1
    while (t.contains(s)) {
        i++
        s=c*i
    }
    println "${c}=${i-1}"
}

— माइकल ईस्टर
स्रोत

क्या वास्तव में अधिकतम अनुक्रम लंबाई की गणना करता है? मैं यह नहीं देखता कि यह कैसे "aabbbbaaaabbbbbba" जैसे स्ट्रिंग के लिए सही तरीके से काम करेगा, हालांकि मैं ग्रूवी को भी नहीं जानता।

— शराबी

यह आपके उदाहरण के लिए काम करता है। मैंने ungolfed संस्करण अद्यतन किया है। ध्यान दें कि "a" * 4 == "aaaa"।

— माइकल ईस्टर

आह, मैं देखता हूं कि अब यह कैसे काम करता है। चतुर।

— शराबी

अधिकतम अनुक्रम लंबाई ज्ञात करें

8086 मशीन कोड, 82 80

सीजेएम, 27 26 25 बाइट्स

उदाहरण

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

जे - 52 बाइट्स

रूबी, ,२

GolfScript, 26 बाइट्स

कॉफ़ीस्क्रिप्ट, 109 बाइट्स

पायथ , 24 25 26 (या 29)

सी, 126 125 119 बाइट्स

गणितज्ञ , 69४ 74२ ६ ९

सी # (लिनक्यूपैड)

146

136

128

122

पायथन 3 (70)

रूबी, ५ Rub

LINQPad में C # - 159 बाइट्स

पॉवरशेल 80 77 72

पर्ल - 65 71 76 वर्ण

एफ # - 106

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

टी-एसक्यूएल (2012) 189 171

हास्केल - 113 120 बाइट्स

जावास्क्रिप्ट [83 बाइट्स]

जावास्क्रिप्ट - 91

जूलिया, 85

पायथन 3 - 111, 126, 115 114 111 बाइट्स

जावास्क्रिप्ट - 141 137 125

जावास्क्रिप्ट, 109 104 100 98 बाइट्स

PHP, 104 102 96

सी 169

जावास्क्रिप्ट 116

ग्रूवी - 80 वर्ण