Cho một chuỗi chỉ chứa các chữ cái, xuất độ dài của chuỗi chữ cái liên tiếp dài nhất mà từ đó chứa, trong đó thứ tự không quan trọng. Một thuật toán ví dụ có thể sắp xếp từ, loại bỏ các bản sao và sau đó xuất độ dài của lần chạy dài nhất.

Các trường hợp thử nghiệm

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

Ví dụ, antidisestablishmentarianismchứa các chữ cái abdehilmnstr. Các bước chạy dài nhất là lmnvà rst, cả hai chiều dài 3.

Ghi chú

Bạn có thể lấy tất cả chữ thường, tất cả chữ hoa hoặc chữ in thường làm đầu vào, nhưng trường hợp không thể mã hóa thông tin về từ đó (nghĩa là bạn không thể nviết hoa các ký tự đầu tiên viết hoa trong đó nđộ dài của lần chạy dài nhất).

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

Thạch ,  10 9 8 7  6 byte

OṬṣ0ZL

Hãy thử trực tuyến!

^{9 đã sử dụng phương pháp của Sok :ṢQẆẇƇØaṪL}

Làm sao?

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

APL (Dyalog Classic) , 10 9 byte

-1 byte nhờ H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Hãy thử trực tuyến!

⍞ nhập một chuỗi

⎕a là bảng chữ cái tiếng Anh viết hoa

⎕a∊⍞ một vectơ có độ dài 26-boolean - những chữ cái nào xuất hiện trong chuỗi?

⊆⍨ dạng vectơ của 1s liên tiếp

≢⍉↑ trộn vào một ma trận, hoán vị và trả về chiều cao của nó - một cách hiệu quả, tìm độ dài của vectơ dài nhất 1s

R , 44 43 byte

Hoạt động trên một loạt các ký tự chữ thường. Chỉnh sửa: đã thay đổi nó từ kiểm tra giá trị True thành nhân với T / F cho một byte.

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

Hãy thử trực tuyến!

Liệu mã hóa chiều dài chạy trên các chữ cái trong các ký tự được cung cấp sau đó trả về giá trị tối đa cho các dấu vết.

Perl 6 , 41 byte

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

Kiểm tra nó

Mở rộng:

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

Cho 'stars', .ords.sort.squish Z-0..*sẽ trở lại(97,113,113,113)

Haskell , 35 byte

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

Hãy thử trực tuyến!

Haskell , 50 byte

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 51 byte

Trường hợp của chuỗi đầu vào không quan trọng.

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

Hãy thử trực tuyến!

Làm sao?

Trước tiên, chúng tôi chuyển đổi chuỗi đầu vào thành một bitmask các chữ cái gặp phải với:

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

Sự thay đổi bitwise được xử lý với một modulo ẩn 32.

Thí dụ:

"feedback" --> 100001111110
               kjihgfedcba-

Sau đó, chúng tôi 'giảm' các lần chạy liên tiếp 1 giây trong bitmask bằng cách lặp lại VÀ'ing nó với một bản sao dịch chuyển trái của chính nó cho đến khi tất cả các bit bị xóa:

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

Số lượng chữ cái liên tiếp theo thứ tự bảng chữ cái là số lần lặp của quá trình trên. Do đó hàm đệ quy:

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

Bình thường , 9 byte

le}#G.:S{

Đầu vào được coi là một chuỗi chữ thường. Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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 byte

2Y2imY'*X>

Đầu vào là chữ thường.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Điều này sử dụng kết hợp các cách tiếp cận của @ Sundar's (cũ) và @ ngn .

Giải trình

Hãy xem xét đầu vào 'tutorial'là một ví dụ.

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 byte

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

Hãy thử trực tuyến!

Python 2 , 58 byte

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

Hãy thử trực tuyến!

Python 2 , 63 byte

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

Hãy thử trực tuyến!

05AB1E , 6 byte

Œ...é$\to$æ

êæAÃθg

Hãy thử trực tuyến!

Ngoài ra 6 byte

Đã lưu 2 byte, một lần nữa nhờ vào Adnan : sử dụng ASåthay vào đó êÇ¥Θ, do đó cũng loại bỏ nhu cầu tăng tối đa ở cuối. Xem lịch sử sửa đổi để so sánh các beviours của hai phương pháp.

ASåγOà

Hãy thử trực tuyến!

Chúng hoạt động như thế nào

Tôi thích những thử thách như thế này dẫn đến nhiều cách tiếp cận khác nhau.

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

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

Đối với đầu vào, sử dụng như sau DECLARE câu lệnh trước mã:

DECLARE @ varchar(200) = 'propinquities';

Dự kiến ​​đầu vào là tất cả các trường hợp giống nhau (trên hoặc dưới không thành vấn đề, nhưng trường hợp hỗn hợp sẽ không hoạt động).

Ung dung:

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

Giải trình:

Chia chuỗi thành một hàng aa cho mỗi ký tự (được điều chỉnh từ /programming//a/27623321/1474939 ) trongCTE cte.

Sau đó, tìm các chuỗi chữ cái liên tiếp bằng cách chuyển đổi sang mã ASCII trong Runscte.

Cuối cùng, nó chọn lần chạy lớn nhất và báo cáo lại trong câu lệnh select.

C (gcc) , 58 56 byte

Đã lưu 2 byte nhờ @gastropner

Sử dụng cách tiếp cận tương tự như câu trả lời Node.js của tôi . Trường hợp của chuỗi đầu vào không quan trọng.

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

Hãy thử trực tuyến!

Đã bình luận

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 byte

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

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

MATL , 12 10 byte

91:wX-dX>q

Hãy thử trực tuyến!

Giải trình:

91:- Tạo danh sách các số từ 1 đến 91. 91 là ký tự '[', xuất hiện sau 'Z'. Vì vậy, điều này tạo hiệu quả danh sách tất cả các ký tự từ '\ x1' đến '['. (Chúng tôi chủ yếu muốn những người trong phạm vi ['A'-1:' Z '+ 1], nhưng phần còn lại không bị tổn thương và cần ít tiền hơn.)

w - Nhập liệu ngầm định, đưa đầu vào lên đầu ngăn xếp (giả sử 'HƯỚNG DẪN')

X- - Đặt chênh lệch. Điều này chỉ để lại các ký tự không được tìm thấy trong chuỗi đầu vào, theo thứ tự ban đầu của chúng ('ổn định'). Cây rơm:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Sự khác biệt giữa các yếu tố liên tiếp trong danh sách đó. Cây rơm:[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> - Lấy tối đa những khác biệt đó là số lượng bảng chữ cái liên tiếp bị thiếu trong chênh lệch đã đặt.

q - Giảm để có được số lượng nhân vật thực tế

Lớn hơn:

12 byte

Sud1=Y'*X>sQ

Hãy thử trực tuyến!

K (ngn / k) , 17 15 byte

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

Hãy thử trực tuyến!

- chỉ có để chuyển đổi ký tự thành số (không thành vấn đề nếu chúng âm)

{ }\ áp dụng một hàm cho đến khi hội tụ, bảo toàn kết quả trung gian

x+1 thêm 1 vào mỗi số trong x

^ "không có" - danh sách bên trái không có các yếu tố xảy ra trong danh sách bên phải

x^x^x+1có nghĩa là xgiao nhau vớix+1

1_ bỏ yếu tố đầu tiên

# đếm

Võng mạc 0.8.2 , 54 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

O`.

Sắp xếp các chữ cái theo thứ tự.

D`.

Lặp lại các chữ cái.

.
$&$&¶

Sao chép từng chữ cái trên các dòng riêng biệt.

T`l`_l`¶.

Giảm đầu tiên của mỗi cặp.

(.)¶\1
$1

Nếu điều này bây giờ phù hợp với nhân vật trước đó, hãy nối chúng lại với nhau.

.(.+)
$.1

Đếm độ dài của tất cả các lần chạy.

O#^`

Sắp xếp chúng theo thứ tự số ngược.

1G`

Lấy cái đầu tiên (lớn nhất).

J, 16 byte

-7 byte nhờ FrownyFrog

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

Hãy thử trực tuyến!

giải trình

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

Cảm ơn Jonathan Frech cho những lời đề nghị.

Chỉ in hoa.

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

Hãy thử trực tuyến!

Japt -h , 9 byte

Case insenstive, lấy đầu vào là một chuỗi hoặc một mảng các ký tự.

;CôkU mÊn

Hãy thử hoặc chạy nhiều thử nghiệm (dòng thứ hai đóng vai trò thay thế cho -hcờ để có thể sử dụng cờ để xử lý nhiều đầu vào thay thế)

Giải trình

              :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 byte

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

Hãy thử trực tuyến .

Ung dung:

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 byte

Giả sử đầu vào chỉ chứa chữ cái viết thường. Đầu tiên, nó lặp qua chuỗi và đặt các bit trong một số nguyên theo các chữ cái được nhìn thấy. Tiếp theo, nó đếm chuỗi dài nhất 1 bit trong số nguyên.

Chỉnh sửa: alà toàn cầu, do đó sẽ được khởi tạo thành 0 ở lần gọi đầu tiên. Vòng lặp thứ hai đảm bảo nó được đặt lại về 0 trước khi quay lại. Do đó, chúng ta có thể tránh đặt lại nó bằng tay.

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

Hãy thử trực tuyến!

Perl 5, 62 + 2 ( -nFcờ) = 64 byte

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

Dùng thử trực tuyến .

Perl 5, 68 byte

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

Hãy thử trực tuyến .

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

Ung dung:

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 byte

{⊇pS∧ẠsSl}ᶠ⌉

Hãy thử trực tuyến!

{        }ᶠ    % 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

Chậm đến mức nó không kết thúc cho đầu vào "chủ nghĩa chống đối lập" trên TIO. Tương đối nhanh hơn nhiều cho +1 byte:

13 byte

{dosS∧ẠsSl}ᶠ⌉

Hãy thử trực tuyến!

Sử dụng dosthay vì ⊇p: S là một deduplicated s orted substring của đầu vào, thay vì chỉ một số hoán vị của một số tập hợp con.

Haskell , 87 byte

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

Hãy thử trực tuyến!

Mong đợi các ký tự chữ thường

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Pyth - 11 byte

le@.:G).:S{

Đầu vào phải được bọc trong dấu ngoặc kép. Nếu không được phép:

Pyth - 12 byte

le@.:G).:S{z

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Java 8, 77 byte

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

Câu trả lời C của cảng Arnauld . Hãy thử trực tuyến tại đây .

Ung dung:

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 byte

Đọc các ký tự chữ thường từ stdin, xuất ra một số thành thiết bị xuất chuẩn.

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

Hãy thử trực tuyế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