लगातार वर्णों की गणना करें

Question

केवल अक्षरों से युक्त एक स्ट्रिंग को देखते हुए, निरंतर वर्णमाला के सबसे लंबे अक्षरों की लंबाई का उत्पादन होता है जिसमें शब्द शामिल होता है, जहां ऑर्डर कोई फर्क नहीं पड़ता। एक उदाहरण एल्गोरिथ्म शब्द को सॉर्ट कर सकता है, डुप्लिकेट को हटा सकता है, और फिर सबसे लंबे समय तक चलने की लंबाई को आउटपुट कर सकता है।

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

watch -> 1
stars -> 3
antidisestablishmentarianism -> 3
backdoor -> 4
a -> 1
tutorials -> 4

उदाहरण के लिए, antidisestablishmentarianismपत्र शामिल हैं abdehilmnstr। सबसे लंबे रन हैं lmnऔर rstदोनों की लंबाई 3 है।

टिप्पणियाँ

आप सभी लोअरकेस, सभी अपरकेस या मिश्रित-केस अक्षरों को इनपुट के रूप में ले सकते हैं, लेकिन मामला शब्द के बारे में जानकारी को सांकेतिक शब्दों में बदलना नहीं कर सकता है (यानी आप पहले nपात्रों को पूंजीकृत नहीं बना सकते हैं जहां nसबसे लंबे समय तक चलने की लंबाई है)।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

Comments

@ H.PWiz, मैं अनुमान लगा रहा हूं कि यह एक टाइपो है और यह होना चाहिए rst- अद्वितीय, सॉर्ट करें और सबसे लंबे समय तक लगातार चलाएं। क्या हम वर्णों के एक सरणी के रूप में इनपुट ले सकते हैं?

— झबरा

@ हाँ, निश्चित रूप से, मैंने इसे शामिल नहीं किया क्योंकि मुझे लगा कि यह एक डिफ़ॉल्ट है

— स्टीफन

क्या 'z ’के निकट jac a’ है -' zebra ’का स्कोर 2 या 3 होना चाहिए?

— जोनाथन एलन

(... आपके उदाहरण एल्गोरिथ्म को देखते हुए मुझे "नहीं" और "2" लगता है)

— जोनाथन एलन

@JonathanAllan आप सही हैं

— स्टीफन

Answer 1

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

OṬṣ0ZL

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

^{9 सोक की विधि का उपयोग कर रहा था :ṢQẆẇƇØaṪL}

कैसे?

OṬṣ0ZL - Link: list of (single-case) characters  e.g.  codegolf
O      - ordinal (vectorises)           [99,111,100,101,103,111,108,102]
 Ṭ     - untruth (1s at those indices)  [0,0,0,...,1,1,1,1,1,0,0,0,0,1,0,0,1]
       -                                 ^         ^       ^         ^     ^
       -                   i.e. indices: 1        99     103       108   111
   0   - literal zero
  ṣ    - split at                       [[],[],[],...,[1,1,1,1,1],[],[],[],[1],[],[1]]
    Z  - transpose                      [[1,1,1],[1],[1],[1],[1]]
     L - length                         5

Answer 2

आर , 44 43 बाइट्स

लोअरकेस वर्णों की एक सरणी पर काम करता है। संपादित करें: इसे परीक्षण से बदलकर सही मानों को बाइट के लिए T / F से गुणा करना है।

function(x,r=rle(letters%in%x))max(r$l*r$v)

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

आपूर्ति वर्णों पर चलने वाले अक्षरों पर एक रन लंबाई एन्कोडिंग करता है, फिर ट्रूज़ के लिए अधिकतम मान लौटाता है।

Comments

Utf8ToInt का उपयोग करके एक समान रीले सॉल्यूशन पर काम कर रहा था, लेकिन स्ट्रिंग की एक सरणी लेना अधिक होशियार है। +1

— JayCe

@JayCe ने उसी तरह से शुरुआत की, लेकिन फिर महसूस किया कि% चेक में एक अक्षर% ने एक झपट्टा में अनोखे और अलग-अलग चरणों का ध्यान

— रखा

Answer 3

एपीएल (डायलॉग क्लासिक) , 10 9 बाइट्स

एच ब्वॉयज को -1 बाइट धन्यवाद

≢⍉↑⊆⍨⎕a∊⍞

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

⍞ एक स्ट्रिंग इनपुट

⎕a अपरकेस अंग्रेजी वर्णमाला है

⎕a∊⍞ बूलियन लंबाई -26 वेक्टर - स्ट्रिंग में कौन से अक्षर होते हैं?

⊆⍨ लगातार 1s के वैक्टर बनाएं

≢⍉↑ एक मैट्रिक्स में मिलाएं, स्थानांतरित करें, और इसकी ऊंचाई वापस करें - प्रभावी रूप से, 1s के सबसे लंबे वेक्टर की लंबाई का पता लगाएं

Comments

⌈/≢¨->≢⍉↑

— H.PWiz

Answer 4

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

{max values bag .ords.sort.squish Z-0..*}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit param $_

  max       # find the max
    values  # get the values from the following Bag (repeat counts)
      bag   # find the repeats

          .ords.sort.squish # get the unique ordinals (method call on $_)
        Z-                  # zip subtract with
          0 .. *            # Range starting with 0
}

दिया 'stars', .ords.sort.squish Z-0..*लौट आएगा(97,113,113,113)

Answer 5

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

f[]=0
f s=1+f[c|c<-s,elem(succ c)s]

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

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

f s=maximum$scanl(\x c->sum[x+1|elem c s])0['a'..]

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

Answer 6

जावास्क्रिप्ट (Node.js) , 51 बाइट्स

इनपुट स्ट्रिंग का मामला मायने नहीं रखता।

s=>(g=_=>s&&1+g(s&=s*2))(Buffer(s).map(c=>s|=1<<c))

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

कैसे?

हम पहली बार इनपुट स्ट्रिंग को सामने वाले अक्षरों के बिटमास्क में बदलते हैं:

Buffer(s).map(c => s |= 1 << c)

बिटवाइज़ शिफ्ट को एक निहित मोडुलो 32 के साथ संसाधित किया जाता है।

उदाहरण:

"feedback" --> 100001111110
               kjihgfedcba-

हम तब तक बिटमस्क में लगातार 1 के रन को 'कम' करते हैं और इसे तब तक छोड़ देते हैं जब तक कि सभी बिट्स साफ़ नहीं हो जाते।

0100001111110 AND 1000011111100 --> 0000001111100
0000001111100 AND 0000011111000 --> 0000001111000
0000001111000 AND 0000011110000 --> 0000001110000
0000001110000 AND 0000011100000 --> 0000001100000
0000001100000 AND 0000011000000 --> 0000001000000
0000001000000 AND 0000010000000 --> 0000000000000

वर्णमाला क्रम में लगातार अक्षरों की संख्या उपरोक्त प्रक्रिया के पुनरावृत्तियों की संख्या है। इसलिए पुनरावर्ती कार्य:

g = _ => s && 1 + g(s &= s * 2)

Answer 7

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

le}#G.:S{

इनपुट को लोअर केस स्ट्रिंग माना जाता है। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

le}#G.:S{Q   Q=eval(input()), G=lowercase alphabet. Trailing Q inferred.

        {Q   Deduplicate input string
       S     Sort it
     .:      Take all substrings (these are generated in length order)
  }#G        Filter out those that aren't found in the alphabet
le           Find the length of the last remaining element

Comments

इस तथ्य का उपयोग करके महान विधि कि सबस्ट्रिंग लंबाई द्वारा आदेशित हैं!

— जोनाथन एलन

यह बहुत कम कुशल होगा, लेकिन आप इसके yस्थान पर उपयोग कर सकते हैं .:।

— FryAmTheEggman

Answer 8

MATL , 10 बाइट्स

2Y2imY'*X>

इनपुट लोअरकेस में है।

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

इसमें @ सुंदर (पुराने) और @ ngn के मिश्रण का उपयोग किया गया है।

व्याख्या

'tutorial'उदाहरण के रूप में इनपुट पर विचार करें ।

2Y2   % Push predefind literal 'abcdefghijklmnopqrstuvwxyz'
      % STACK: 'abcdefghijklmnopqrstuvwxyz'
i     % Push input
      % STACK: 'abcdefghijklmnopqrstuvwxyz', 'tutorials'
m     % Ismember: true for letters present in the input
      % STACK: [1 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 1 1 1 0 0 0 0 0]
Y'    % Run-length encoding
      % STACK: [1 0 1 0 1 0 1 0 1 0], [1 7 1 2 1 2 1 2 4 5]
*     % Multiply, element-wise
      % STACK: [1 0 1 0 1 0 1 0 4 0]
X>    % Maximum. Implicitly display
      % STACK: 4

Answer 9

पायथन 3 , 55 बाइट्स

f=lambda s:s and-~f({*s}&{chr(ord(c)+1)for c in s})or 0

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

---

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

f=lambda s,c=99,r=0:c and max(r,f(s,c-1,-~r*(chr(c)in s)))

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

---

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

n=t=0
for c in input():n|=2**ord(c)
while n:n&=n/2;t+=1
print t

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

Comments

इनपुट के रूप में python3 बाइट्स का उपयोग करने के बारे में क्या f=lambda s:s and-~f({*s}&{c+1for c in s})or 0:?

— विंसेंट

Answer 10

05AB1E , 6 बाइट्स

Œ...é$\to$æ

êæAÃθg

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

इसके अलावा 6 बाइट्स

सहेजे गए 2 बाइट्स, फिर से अदनान के लिए धन्यवाद : ASåइसके बजाय का उपयोग करना êÇ¥Θ, इस प्रकार अंत में अधिकतम वेतन वृद्धि की आवश्यकता को भी दूर करना। दो तरीकों के बीवरों की तुलना करने के लिए संशोधन इतिहास देखें ।

ASåγOà

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

वे कैसे काम करते हैं

मुझे इस तरह की चुनौतियाँ पसंद हैं, जो विभिन्न दृष्टिकोणों को जन्म देती हैं।

êæAÃθg | Full program.
ê      | Push a sorted and without duplicates version of the input.
 æ     | Powerser.
  AÃ   | Keep those that also occur in the lowercase alphabet.
    θg | Take the length of the last one. θ and ` can be used interchangeably.
-------+-------------------------------------------------------------------------------
ASåγOà | Full program.
A      | Push the lowercase alphabet.
 S     | Listify it (i.e. convert it to a sequence of characters).
  å    | Replace each char in the alphabet by 1 if its in the input, else by 0.
   γ   | Split into chunks of equal adjacent elements.
    O  | Sum each part.
     à | Extract the maximum of this list. Again, à and Z can be used interchangeably.

Comments

पहले कार्यक्रम को गोल्फ के लिए êæAÃ`gऔर दूसरे कार्यक्रम को गोल्फ के लिए रखा जा सकता है ASåγOZ।

— अदनान

@ अदनान धन्यवाद, अपडेट! मुझे ASåतरकीब पसंद है ।

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

Answer 11

TSQL (Microsoft SQL सर्वर), 206 बाइट्स

WITH C AS (SELECT 1p,SUBSTRING(@,1,1)c UNION ALL SELECT p+1,SUBSTRING(@,p+1,1)FROM C WHERE p<LEN(@)),R AS(SELECT c d,1r FROM C UNION ALL SELECT c,r+1FROM R JOIN c ON ASCII(d)+1=ASCII(c))SELECT MAX(r)FROM R

इनपुट के लिए, DECLAREकोड से पहले निम्नलिखित कथन का उपयोग करें :

DECLARE @ varchar(200) = 'propinquities';

यह उम्मीद की जाती है कि इनपुट सभी समान मामला है (ऊपरी या निचला कोई फर्क नहीं पड़ता, लेकिन मिश्रित मामला काम नहीं करेगा)।

Ungolfed:

DECLARE @data varchar(200) = 'propinquities'

;WITH CTE AS (
    SELECT
        1 as CharacterPosition,
        SUBSTRING(@data,1,1) as Character
    UNION ALL
    SELECT
        CharacterPosition + 1,
        SUBSTRING(@data,CharacterPosition + 1,1)
    FROM
        CTE
    WHERE CharacterPosition < LEN(@data)
), Runs AS
(
    SELECT Character, 1 rc
    FROM CTE
    UNION ALL
    SELECT b.Character, rc + 1
    FROM Runs r
    JOIN CTE b ON ASCII(r.Character) + 1 = ASCII(b.Character)
)
SELECT max(rc)
from runs

स्पष्टीकरण:

सीटी में प्रत्येक वर्ण के लिए स्ट्रिंग को प्रत्येक पंक्ति में विभाजित किया गया ( /programming//a/27623321/1474939 से अनुकूलित ) CTE।

फिर, RunsCte में ASCII कोड में परिवर्तित करके लगातार अक्षरों के रन पाता है ।

अंत में, यह सबसे बड़ा रन चुनता है और चुनिंदा स्टेटमेंट में वापस रिपोर्ट करता है।

Comments

अच्छा जवाब, CTE का बहुत अच्छा उपयोग। सुनिश्चित नहीं है कि यह आपकी बाइट की गिनती में मदद करेगा या चोट पहुंचाएगा, लेकिन टी-एसक्यूएल में इनपुट प्राप्त करने के लिए "स्वीकृत" विधि पूर्व-निर्मित तालिका के माध्यम से है ।

— ब्रैड

@ ब्रैडेक यदि मैं प्रत्येक पंक्ति के साथ एक तालिका को एक वर्ण के रूप में ले सकता हूं (एक स्ट्रिंग के बजाय एक चार सरणी की तरह), तो यह एक सीटीई को हटाने में मदद करेगा। यदि यह अभी भी एक पंक्ति होना है, तो यह संभवतः इनपुट चर के रूप में लेने के समान है। हालांकि विचार के लिए धन्यवाद!

— ब्रायन जे।

Answer 12

सी (जीसीसी) , 58 56 बाइट्स

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

मेरे Node.js उत्तर के समान दृष्टिकोण का उपयोग करता है । इनपुट स्ट्रिंग का मामला मायने नहीं रखता।

m,i;f(char*s){for(i=0;*s?m|=1<<*s++:(i++,m&=m*2););s=i;}

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

टिप्पणी की गई

m,                   // m = bitmask of encountered letters
i;                   // i = counter of max. consecutive letters
f(char *s) {         // f = function taking the input string s
  for(               // main loop:
    i = 0;           //   start with i = 0 and assume m = 0 on first call
                     //   (it is forced back to 0 when the program terminates)
    *s ?             //   if we haven't reached the end of the string:
      m |= 1 << *s++ //     update m by setting the appropriate bit for this character
                     //     (with implicit modulo 32) and advance the string pointer
    : (              //   else:
        i++,         //     increment i
        m &= m * 2   //     'reduce' runs of consecutive 1's in m by AND'ing it with a
      );             //     left-shifted copy of itself (e.g. 11101 & 111010 -> 11000;
                     //     11000 & 110000 -> 10000); we stop when m = 0
  );                 // end of for()
  s = i; }           // return i

Comments

क्या यह कार्यान्वयन विशिष्ट है जो 1<<*sलपेटता है या क्या यह मानक व्यवहार है?

— जोनाथन फ्रीच

@JonathanFrech मुझे लगता है कि यह आधिकारिक तौर पर अपरिभाषित व्यवहार है। तो यह कार्यान्वयन विशिष्ट होना चाहिए।

— अरनुलद

क्योंकि दिलचस्प रूप से यह केवल तभी रैप करने के लिए प्रकट होता है जब इसे रनटाइम पर गणना की जाती है। संकलन समय 1<<32पर 0डेटा प्रकार आकार चेतावनी जारी करता है और जारी करता है।

— जोनाथन फ्रीच

दरअसल, मुझे संदेह है कि संकलक स्पष्ट रूप से 5-बिट मुखौटा लागू करेगा। संभावना है कि यह सीपीयू स्तर पर किया गया है।

— अरनुलद

@Arnauld यह है (नोट देखें: "[...] गिनती ऑपरेंड एक तत्काल मान हो सकता है या सीएल को पंजीकृत कर सकता है। गिनती 5 बिट्स की है, जो गिनती सीमा को 0 से 31 तक सीमित करती है।")

— ErikF

Answer 13

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

c,o,u;n(t,e,r)char*r,*e,*t;{for(u=0,e=t;c=*t++;u=u<o?o:u)for(o=0,r=e;*r;*r++-c||(c++,r=e,++o));o=u;}

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

व्याख्या

c,o,u;n(t,e,r)    // setup, function declaration
char*r,*e,*t;{    // K&R style
 for(u=0,e=t;     // initialize global maximum u to 0, write string start to e
 c=*t++;          // look at every character in the string
 u=u  <o?o:  u)   // funny face
  for(o=0,r=e;*r; // initialize local maximum o to 0, look at entire string again
  *r++-c||(c++,   // equal character found, search for next one
   r=e,++o));     // reset local pointer, increment local maximum
o=u;}             // return maximum character streak

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

Comments

+1 के लिए "c, o, u; n (t, e, r)" :)

Answer 14

MATL , 12 10 बाइट्स

91:wX-dX>q

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

स्पष्टीकरण:

91:- संख्याओं की सूची 1 से 91 तक बनाएं। वर्ण '' '' है, जो 'Z' के बाद आता है। इसलिए यह प्रभावी रूप से '\ X1' से '[' तक सभी वर्णों की सूची बनाता है। (हम मुख्य रूप से उन [[A-1: 'Z' + 1] श्रेणी में चाहते हैं, लेकिन बाकी को चोट नहीं लगी है, और कम बायटेकाउंट की आवश्यकता है।)

w - अंतर्निहित इनपुट, स्टैक के शीर्ष पर इनपुट लाएं (मान लें कि 'TUTORIALS')

X- - अंतर सेट करें। यह केवल उन वर्णों को छोड़ता है जो इनपुट स्ट्रिंग में नहीं मिले थे , अपने मूल क्रम ('स्थिर') में। ढेर:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - उस सूची में क्रमिक तत्वों के बीच अंतर। ढेर:[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 2 1 2 1 2 1 5 1 1 1 1 1]

X> - उन अंतरों का अधिकतम लाभ उठाएं यानी सेट अंतर से लगातार गायब होने वाले अधिकतम अक्षर।

q - वास्तविक चरित्र गणना प्राप्त करने में कमी

---

पुराने:

12 बाइट्स

Sud1=Y'*X>sQ

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

Comments

इतने सारे दृष्टिकोण :-)

— लुइस मेंडो

Answer 15

के (ngn / k) , १ k १५ बाइट्स

#1_{x^x^x+1}\-:

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

- केवल वर्णों को संख्याओं में परिवर्तित करने के लिए है (यह नकारात्मक होने पर कोई फर्क नहीं पड़ता)

{ }\ अभिसरण तक एक फ़ंक्शन लागू करता है, मध्यवर्ती परिणामों को संरक्षित करता है

x+1 में प्रत्येक संख्या में 1 जोड़ें x

^ "बिना" - दाईं ओर की सूची में होने वाले तत्वों के बिना बाईं ओर की सूची

x^x^x+1के xसाथ मतलब हैx+1

1_ पहला तत्व छोड़ो

# गिनती

Comments

#1_{x^x^x+1}\-?

— एडम जूल

@ एडम हां, एक दिन मुझे ट्रेनों का काम करना चाहिए ...

— ngn

अभिसरण के साथ चौराहे के रूप में इस अवधारणा को अभिसरण तक काफी अच्छा है

— योना

ट्रेनें काम करती हैं

— ngn

Answer 16

रेटिना 0.8.2 , 54 बाइट्स

O`.
D`.
.
$&$&¶
T`l`_l`¶.
(.)¶\1
$1
.(.+)
$.1
O#^`
1G`

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

O`.

अक्षरों को क्रम में क्रमबद्ध करें।

D`.

पत्रों को डुप्लिकेट करें।

.
$&$&¶

प्रत्येक अक्षर को अलग-अलग लाइनों पर डुप्लिकेट करें।

T`l`_l`¶.

प्रत्येक जोड़ी में से पहला घटाना।

(.)¶\1
$1

यदि यह अब पिछले चरित्र से मेल खाता है, तो उन्हें वापस एक साथ जोड़ दें।

.(.+)
$.1

सभी रनों की लंबाई गिनें।

O#^`

उन्हें उल्टे संख्यात्मक क्रम में क्रमबद्ध करें।

1G`

पहले (सबसे बड़ा) लो।

Answer 17

जे, 16 बाइट्स

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

[:>./a.#;._1@e.]

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

व्याख्या

[: >./ a. #;._1@e. ]    
       a. (    )e. ]    is the ascii alphabet an element of the input:
                        this will transform the alphabet into a 1-0 array,
                        the ones representing the letters in the input
          #;._1@        split that 1-0 list up into pieces, using 0
                        as the delimiter, and transforming each chunk
                        into its length. now we have a list of ints
[: >./                  take the max 

Comments

मुझे लगता है कि आप वर्णमाला के ]बजाय उपयोग कर सकते हैं ~.@/:~पहले से ही सॉर्ट किया गया है, इसलिए आपको इनपुट को क्रमबद्ध करने और केवल अनन्य आइटम रखने की आवश्यकता नहीं है। TIO - 18 बाइट्स

— गैलेन इवानोव

16

— फ्रॉन्फ्रोग जूल

@FrownyFrog और गैलेन, आप दोनों को धन्यवाद! पूर्वव्यापी में यह स्पष्ट होना चाहिए था कि मुझे पहले uniq / सॉर्ट की आवश्यकता नहीं थी।

— जोनाह

Answer 18

सी (जीसीसी) , 98 92 बाइट्स

सुझाव के लिए जोनाथन फ्रेच को धन्यवाद।

अपरकेस-केवल।

f(char*s){int a[99]={0},i,j,k=j=i=0;for(;*s;a[*s++]++);for(;i<99;j=!!a[i++]*++j,k=j>k?j:k);}

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

Comments

आपको वास्तव k;में अंत में आवश्यकता नहीं है । इंप्लिक्ट जीसीसी रिटर्न वैरिएबल असाइनमेंट का एक साइड इफेक्ट है, जो लूप में आपके अंतिम चरण के रूप में दिखाई देता है।

— जोनाथन फ्रेच

संभावित 95 बाइट्स ।

— जोनाथन फ्रीच

@JonathanFrech मुझे जीसीसी के निहित रिटर्न पर भरोसा नहीं है। वे हमेशा उस तरह से नहीं होते हैं जिसकी मैं उनसे अपेक्षा करता हूं, और वे अक्सर पॉइंटर्स और फ्लोटिंग-पॉइंट के लिए बिल्कुल भी काम नहीं करते हैं। सौभाग्य से, कोड गोल्फ के बाहर मैं कभी भी उनका उपयोग नहीं करता! :-)

— यूरिकएफ

Answer 19

जाप -h , 9 बाइट्स

मामले को असंवेदनशील, एक स्ट्रिंग या वर्णों के रूप में इनपुट लेता है।

;CôkU mÊn

इसे आज़माएं या कई परीक्षण चलाएं (दूसरी पंक्ति -hध्वज के प्रतिस्थापन के रूप में कार्य करती है, इसलिए ध्वज का उपयोग इसके बजाय कई इनपुट संसाधित करने के लिए किया जा सकता है)

---

व्याख्या

              :Implicit input of string/array U
;C            :The lowercase alphabet
  ô           :Partition at characters returning truthy
   kU         :  Remove all characters in U from the current letter
              :  This will return a non-empty string (truthy) if the current letter ISN'T in U
     m        :Map
      Ê       :  Length
       n      :Sort
              :Implicitly output the last element in the array

Comments

@Downvoter, क्या आप -1कृपया अपना कारण बता सकते हैं ?

— झबरा

Answer 20

पर्ल 5, 68 बाइट्स

$"=<>;map{$"=~/$_/i&&++$$_||last for$_..z;$.=$$_ if$$_>$.}a..z;say$.

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

Ungolfed:

use feature 'say';

my $s = <>;
my $r;
for ('a' .. 'z') {
    my $c = 0;
    for ($_ .. 'z') {
        last if $s !~ /$_/i;
        $c++;
    }
    $r = $c if $c > $r;
}
say($r);

Answer 21

सी (जीसीसी) , 66 65 63 बाइट्स

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

संपादित करें: aवैश्विक है, इसलिए पहली कॉल पर 0 से आरंभ किया जाएगा। दूसरा लूप यह सुनिश्चित करता है कि लौटने से पहले इसे 0 पर रीसेट कर दिया जाए। इसलिए, हम इसे मैन्युअल रूप से रीसेट करने से बच सकते हैं।

a,l;f(char*s){for(l=0;*s;)a|=1<<*s++-97;for(;a;l++)a&=a*2;s=l;}

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

Answer 22

पर्ल 5, 62 + 2 ( -nFध्वज) = 64 बाइट्स

$c[ord lc$_]=1for@F;$y[y///c]++for"@c "=~/((1 )+)/g}{say@y/2|0

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

पर्ल 5, 68 बाइट्स

<>=~s/./$c[ord lc$&]=1/gre;$y[y///c]++for"@c "=~/((1 )+)/g;say@y/2|0

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

Comments

अच्छा तरीका! मैंने उस विधि पर बिल्कुल विचार नहीं किया है ... आप कुछ बाइट्स का उपयोग करके -pFऔर -MList::Util+(max)56 पर पाने के लिए बचा सकते हैं : इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

@DomHastings -MList::Util=maxने परिणाम स्कोर में 16 बाइट्स जोड़े।

— डेनिस इबाव जूल

यदि मैं नए स्कोरिंग को सही ढंग से समझता हूं, तो कमांड-लाइन झंडे को बाइट्स के रूप में नहीं गिना जाता है, लेकिन एक अलग से रन की गई भाषा के रूप में, इसलिए केवल पर्ल के बजाय, यह पर्ल के साथ -MList::Util+(max) -pFया इसी तरह होगा। codegolf.meta.stackexchange.com/a/14339/9365

— डोम हेस्टिंग्स

Answer 23

SQLite 265

WITH w AS(SELECT'a'w),n AS(SELECT 1 n UNION ALL SELECT n+1 FROM n LIMIT(SELECT length(w)FROM w)),l AS(SELECT substr(w,n,1)l FROM n,w)SELECT max(v)FROM(SELECT min(n)v FROM(SELECT*FROM l,n EXCEPT SELECT l.l,unicode(l.l)-unicode(b.l)d FROM l,l b WHERE d>0)GROUP BY l);

Ungolfed:

WITH w AS (SELECT 'antidisestablishmentarianism' w)
   , n AS (SELECT 1 n
           UNION ALL
           SELECT n+1 FROM n
           LIMIT (SELECT length(w) FROM w) )
   , l AS (SELECT DISTINCT substr(w,n,1) l FROM n,w ORDER BY l)
   , d AS (
           SELECT l,n FROM l,n
           EXCEPT
           SELECT a.l l, unicode(a.l) - unicode(b.l) d 
           FROM l a, l b 
           WHERE d > 0 
           )

SELECT max(v) FROM ( SELECT min(d.n) v FROM d GROUP BY d.l );

Answer 24

ब्रेकीलॉग , 14 13 12 बाइट्स

{⊇pS∧ẠsSl}ᶠ⌉

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

{        }ᶠ    % Find all values that satisfy this predicate
           ⌉   % And get their maximum
               % The predicate being:
 ⊇pS           % There exists a permutation of a subset of the input
               %  Call it S
    ∧          % And, 
      sS       % S is a substring of
     Ạ         %  the set of alphabets, Ạ, 
        l      % Then, the length of that substring is the return value of the 
               %  predicate

यह पर्याप्त है कि यह TIO पर "एंटीडिसिस्टेब्लिशमेंटरिज़्म" के इनपुट के लिए खत्म न हो। +1 बाइट के लिए अपेक्षाकृत अधिक तेज़

13 बाइट्स

{dosS∧ẠsSl}ᶠ⌉

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

dosइसके बजाय का उपयोग करें ⊇p: एस इनपुट का एक dनुकीला s orted substring है, बजाय कुछ उपसमूह के कुछ क्रमपरिवर्तन के।

Answer 25

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

import Data.List
maximum.map length.filter(`isInfixOf`['a'..'z']).subsequences.nub.sort

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

लोअरकेस वर्णों की अपेक्षा करता है

स्पष्टीकरण:

maximum.map length.filter(`isInfixOf`['a'..'z']).subsequences.nub.sort
                                                                  sort {- sort the characters -}
                                                              nub      {- remove duplicates -}
                                                 subsequences          {- all subsequences -}
                   filter(`isInfixOf`['a'..'z'])                       {- all characters are adjacent -}
        map length                                                     {- length of filtered subsequences -}
maximum                                                                {- maxmimum length -}

Answer 26

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

lambda s:max(reduce(lambda(p,v),c:(c,v+[v[-1]*(c==p+1)+1]),map(ord,sorted(set(s))),(0,[0]))[1])

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

Answer 27

पायथ - 11 बाइट्स

le@.:G).:S{

इनपुट को उद्धरणों में लपेटा जाना चाहिए। यदि अनुमति नहीं है:

पायथ - 12 बाइट्स

le@.:G).:S{z

स्पष्टीकरण:

l(
  e(
    @(
      .:(G),
      .:(
         S(
           {(Q)
         )
      )
    )
  )
)
length(
    last element(
        intersection(
            all positive length substrings(the alphabet as string),
            all positive length substrings(
                sorted(
                    uniquified(input)
                )
            )
        )
    )
)

Answer 28

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

{w:String->{var s=0
var m=0
for(c in 'a'..'z')if(c in w)s++
else{if(s>m)m=s
s=0}
if(s>m)m=s
m}()}

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

Answer 29

जावा 8, 77 बाइट्स

int i,j,m;
c->{for(i=j=0;(m=j<c.length?m|1<<c[j++]:m&m*2+0*++i)>0;);return i;}

पोर्ट ऑफ अरनल्ड का सी उत्तर । इसे यहाँ ऑनलाइन आज़माएँ ।

Ungolfed:

int i, j, m; // instance variables of the surrounding class - initialised to 0
c -> { // lambda - c is of type char[]; return type is int
    for(i = j = 0; // i is the length of the longest run, j is used to step through c - both start at 0
        (m = j < c.length // work with the bitmask of all the letters present in c: if we have not reached the end of c ...
             ? m | 1 << c[j++] // ... set the bit corresponding to the current character, advance one character ...
             : m & m * 2 + 0 * ++i) > 0 ;) ; // ... else reduce runs of consecutively set bits in m by AND-combining it with a left-shifted copy of itself until m hits 0
    return i; // return the result - by now m is back to 0
}

Answer 30

> <> , 63 बाइट्स

स्टड से लोअरकेस वर्ण पढ़ता है, स्टडआउट के लिए एक नंबर आउटपुट करता है।

0l55*)?\
8/?(0:i<]r1~r[-*c
~/00
}</?)@:{:*+1/?(3l
  \~:03. ;n~/

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

0l55*)?\             Push 26 zeroes onto the stack

Record which characters are used
      i              Read a character from the input
 /?(0:               Check if it is -1, marking the end of the input
8             -*c    Subtract 96 from the character code, 
                         giving 1 for 'a', 2 for 'b' etc.
            r[       Pop that many values on to a new stack and reverse 
                         it, putting that character's value at the top of 
                         the stack
          1~         Write 1 to that value
        ]r           Return the stack back to it's normal state

Count the longest run of ones in the stack
  00                 Push values for currentRun = 0, and bestRun = 0
}                    Move bestRun to the bottom of the stack
            /?(3l    Check if there are only 2 values left on the stack
          +1         Increment currentRun
         *           Multiply currentRun by the next value in the stack, 
                         resetting it to 0 if the run is broken
  /?)@:{:            Check if currentRun > bestRun
  \~:                Overwrite bestRun if so
     03.             Jump back to the start of loop
         ;n~/        Once all values have been consumed, 
                         print bestRun and exit