Yalnızca harfleri içeren bir dize verildiğinde, sıranın önemli olmadığı, art arda sıralanan alfabetik harflerin uzunluğunun uzunluğunun çıktısını alın. Örnek bir algoritma sözcüğü sıralayabilir, kopyaları kaldırabilir ve ardından en uzun çalışmanın uzunluğunu çıkarabilir.

Test Kılıfları

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

Örneğin antidisestablishmentarianism, harfleri içerir abdehilmnstr. En uzun ishal olan lmnve rsthem uzunluk 3.

notlar

Tüm küçük harfleri, bütün büyük harfleri veya karışık harfleri girdi olarak alabilirsiniz, ancak harf kelimesi hakkındaki bilgileri kodlayamaz (yani , en uzun satırın uzunluğu olan ilk nkarakterleri büyük harf yapamazsınız n).

Bu kod golf , bayt cinsinden en kısa cevap kazanır.

Jöle ,  10 9 8 7  6 bayt

OṬṣ0ZL

Çevrimiçi deneyin!

^{9 Sok'un metodunu kullanıyordu :ṢQẆẇƇØaṪL}

Nası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

R , 44 43 bayt

Bir küçük harf dizisi üzerinde çalışır. Düzenleme: Gerçek değerleri test etmekten bir bayt için T / F ile çarpmaya değiştirdi.

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

Çevrimiçi deneyin!

Verilen karakterlerde bulunan harfleri kodlayan bir satır uzunluğu mu, sonra trues için maksimum değeri döndürür.

APL (Dyalog Klasik) , 10 9 bayt

H.PWiz sayesinde -1 bayt

≢⍉↑⊆⍨⎕a∊⍞

Çevrimiçi deneyin!

⍞ bir dize girdi

⎕a Büyük harf İngilizce alfabedir

⎕a∊⍞ bir boolean uzunluk-26 vektörü - dizgede hangi harfleri görür

⊆⍨ ardışık 1s form vektörleri

≢⍉↑ bir matrise karıştırın, transpoze edin ve yüksekliğini döndürün - etkili bir şekilde, en uzun 1s vektörünün uzunluğunu bulun

Perl 6 , 41 bayt

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

Dene

Expanded:

{  # 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
}

Verilen 'stars', .ords.sort.squish Z-0..*dönecekti(97,113,113,113)

Haskell , 35 bayt

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

Çevrimiçi deneyin!

Haskell , 50 bayt

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 51 bayt

Giriş dizgisinin durumu önemli değil.

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

Çevrimiçi deneyin!

Nasıl?

Öncelikle giriş dizesini şu harflerle karşılaşılan bir bit maskesine dönüştürürüz:

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

Bitsel kaydırma, kapalı bir modulo 32 ile işlenir.

Örnek:

"feedback" --> 100001111110
               kjihgfedcba-

Ardından bit maskesindeki art arda 1'lerin çalışmalarını art arda AND'layarak “tüm bitler temizlenene kadar sola kaydırılmış bir kopyasıyla” azaltırız:

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

Alfabetik sıradaki ardışık harflerin sayısı, yukarıdaki işlemin yinelemelerinin sayısıdır. Dolayısıyla özyinelemeli işlevi:

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

Pyth , 9 bayt

le}#G.:S{

Giriş küçük harfli bir dize olarak kabul edilir. Online Deneyin burada ya bir kerede tüm test durumları doğrulamak burada .

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

MATL , 10 bayt

2Y2imY'*X>

Giriş küçük harflidir.

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

Bu bir karışımını kullanır Sundar en @ (eski) ve @ ngn en yaklaşımlar.

açıklama

'tutorial'Bir örnek olarak girişi düşünün .

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

Python 3 , 55 bayt

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

Çevrimiçi deneyin!

Python 2 , 58 bayt

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

Çevrimiçi deneyin!

Python 2,63 bayt

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

Çevrimiçi deneyin!

05AB1E , 6 bayt

Œ...é$\to$æ

êæAÃθg

Çevrimiçi deneyin!

Ayrıca 6 bayt

Yine Adnan sayesinde 2 bayt kurtardı : ASåbunun yerine kullanmak êÇ¥Θ, böylece sonunda maksimumu arttırma ihtiyacını ortadan kaldırmak. İki yöntemin eğimini karşılaştırmak için revizyon geçmişine bakın .

ASåγOà

Çevrimiçi deneyin!

Bunlar nasıl çalışır?

Bunun gibi farklı yaklaşımlara yol açan zorlukları severim.

êæ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.

TSQL (Microsoft SQL Server), 206 bayt

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

Giriş için, DECLAREkoddan önce aşağıdaki ifadeyi kullanın :

DECLARE @ varchar(200) = 'propinquities';

Girdilerin hepsinin aynı durumda olması beklenir (üst veya alt fark etmez, ancak karışık durum işe yaramaz).

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

Açıklama:

Dizgiyi her karakter için aa satırına böler ( /programming//a/27623321/1474939 adresinden uyarlanmıştır ).CTE .

Ardından, Runscte'deki ASCII koduna dönüştürerek art arda gelen harfleri bulur .

Son olarak, en büyük koşuyu seçer ve select deyiminde tekrar rapor verir.

C (gcc) , 58 56 bayt

@Gastropner sayesinde 2 bayt kaydedildi

Node.js cevabımla aynı yaklaşımı kullanır . Giriş dizgisinin durumu önemli değil.

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

Çevrimiçi deneyin!

Yorumlananlar

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

C (gcc) , 100 bayt

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;}

Çevrimiçi deneyin!

açıklama

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

Çevrimiçi deneyin!

MATL , 12 10 bayt

91:wX-dX>q

Çevrimiçi deneyin!

Açıklama:

91:- 1'den 91'e kadar olan sayıların listesini oluşturun. 91 'Z' harfinden sonra gelen '[' karakteridir. Böylece bu, '\ x1' den '[' e kadar olan tüm karakterlerin listesini etkin bir şekilde oluşturur. (Biz esas olarak ['A'-1:' Z '+ 1] aralığında olanları istiyoruz, ancak geri kalanının canı yanmıyor ve daha az bytecount gerektiriyor.)

w - Örtülü giriş, girişi yığının üstüne getir ('TUTORIALS' varsayımı)

X- - Farkı ayarla. Bu yapraklar edildi yalnızca karakterlerin değil kendi orijinal sırada ( 'kararlı') 'de, giriş dizesi bulundu. Stack:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Bu listedeki art arda elemanları arasındaki fark. Stack:[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> - Bu farkların maksimumunu, yani ayarlanan farktan eksik ardışık maksimum alfabe sayısını elde edin.

q - Gerçek karakter sayımı almak için azalma

Daha eski:

12 bayt

Sud1=Y'*X>sQ

Çevrimiçi deneyin!

K (ngn / k) , 17 15 bayt

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

Çevrimiçi deneyin!

- sadece karakterleri sayılara dönüştürmek için var mı (negatif olması önemli değil)

{ }\ yakınsama koruyarak yakınsama kadar bir fonksiyon uygular

x+1 içindeki her numaraya 1 ekle x

^ "without" - sağdaki listede meydana gelen elementler olmadan soldaki liste

x^x^x+1xile kesişen anlamına gelirx+1

1_ ilk elemanı düşür

# saymak

Retina 0.8.2 , 54 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

O`.

Harfleri sıraya göre sıralayın.

D`.

Harfleri tekilleştirin.

.
$&$&¶

Her harfi ayrı satırlarda çoğalt.

T`l`_l`¶.

Her çiftin ilkini azaltın.

(.)¶\1
$1

Bu şimdi önceki karakterle eşleşiyorsa, onları tekrar birleştirin.

.(.+)
$.1

Tüm çalışmaların uzunluklarını sayın.

O#^`

Bunları ters sayısal sırayla sıralayın.

1G`

İlkini al (en büyük).

J, 16 bayt

FrownyFrog sayesinde -7 bayt

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

Çevrimiçi deneyin!

açıklama

[: >./ 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 

C (gcc) , 98 92 bayt

Önerileriniz için Jonathan Frech'e teşekkürler.

Büyük harf okunur.

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);}

Çevrimiçi deneyin!

Japt -h , 9 bayt

Büyük küçük harf, girişi dize veya karakter dizisi olarak alır.

;CôkU mÊn

Deneyin veya çoklu testler yapın (ikinci satır -hbayrak yerine geçer, böylece bayrak bunun yerine birden çok girişi işlemek için kullanılabilir)

açıklama

              :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

Perl 5, 68 bayt

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

Çevrimiçi deneyin .

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);

C (gcc) , 66 65 63 bayt

Girişin yalnızca küçük harfler içerdiğini varsayar. Birincisi, dize üzerinde dolaşır ve bitleri harflerin göründüğü şekilde bir tamsayıya ayarlar. Daha sonra, tamsayıdaki en uzun 1 bit çizgisini sayar.

Düzenle: a geneldir, bu nedenle ilk aramada 0 olarak başlatılır. İkinci döngü geri dönmeden önce 0'a sıfırlanmasını sağlar. Bu nedenle, elle sıfırlamaktan kaçınabiliriz.

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

Çevrimiçi deneyin!

Perl 5, 62 + 2 ( -nFbayrak) = 64 bayt

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

Çevrimiçi deneyin .

Perl 5, 68 bayt

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

Çevrimiçi deneyin .

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 );

Brachylog , 14 13 12 bayt

{⊇pS∧ẠsSl}ᶠ⌉

Çevrimiçi deneyin!

{        }ᶠ    % 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’ya “antidisestablishmentarianism” girişi için bitmeyecek kadar yavaş. +1 bayt için nispeten daha hızlı olanı:

13 bayt

{dosS∧ẠsSl}ᶠ⌉

Çevrimiçi deneyin!

Kullanım dosyerine ⊇p: S olduğu deduplicated s orted substring girdi yerine kısmını da sadece bazı permütasyon.

Haskell , 87 bayt

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

Çevrimiçi deneyin!

Küçük harfli karakterler bekliyor

Açıklama:

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 -}

Python 2,95 bayt

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

Çevrimiçi deneyin!

Pyth - 11 bayt

le@.:G).:S{

Giriş, tırnak içine alınmalıdır. İzin verilmezse:

Pyth - 12 bayt

le@.:G).:S{z

Açıklama:

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

Kotlin , 97 bayt

{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}()}

Çevrimiçi deneyin!

Java 8, 77 bayt

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;}

Arnauld Limanı'nın C cevabı . Burada çevrimiçi deneyin .

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
}

> <> , 63 bayt

Stdin'den küçük harfleri okur, stdout'a bir sayı verir.

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

Çevrimiçi deneyin!

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