문자 만 포함하는 문자열이 주어지면 순서에 관계없이 단어에 포함 된 연속 알파벳 문자의 가장 긴 실행 길이를 출력하십시오. 예제 알고리즘은 단어를 정렬하고 중복을 제거한 다음 가장 긴 실행 길이를 출력 할 수 있습니다.

테스트 사례

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

예를 들어, antidisestablishmentarianism글자가 포함되어 있습니다 abdehilmnstr. 가장 긴 실행은 lmn하고 rst, 모두 길이 3의.

노트

모든 소문자, 모든 대문자 또는 대소 문자를 입력으로 사용할 수 있지만 대소 문자는 단어에 대한 정보를 인코딩 할 수 없습니다 (즉, 첫 번째 n문자 n는 가장 긴 실행 길이 인 대문자를 만들 수 없습니다 ).

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

젤리 ,  10 9 8 7  6 바이트

OṬṣ0ZL

온라인으로 사용해보십시오!

^{9는 Sok의 방법을 사용했습니다 .Ṣ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

R , 44 43 바이트

소문자 배열에서 작동합니다. 편집 : True 값 테스트에서 바이트에 대한 T / F 곱으로 변경했습니다.

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

온라인으로 사용해보십시오!

제공된 문자에있는 문자에 대해 실행 길이 인코딩을 수행 한 후 true의 최대 값을 리턴합니다.

APL (Dyalog Classic) , 10 9 바이트

H.PWiz 덕분에 -1 바이트

≢⍉↑⊆⍨⎕a∊⍞

온라인으로 사용해보십시오!

⍞ 문자열을 입력

⎕a 대문자 영어 알파벳입니다

⎕a∊⍞ 부울 길이-26 벡터-문자열에서 어떤 문자가 발생합니까?

⊆⍨ 연속 1의 형태 벡터

≢⍉↑ 행렬로 혼합하고, 조옮김하고, 높이를 반환합니다. 효과적으로 1의 가장 긴 벡터의 길이를 찾습니다

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

하스켈 , 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'..]

온라인으로 사용해보십시오!

자바 스크립트 (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-

그런 다음 모든 비트가 지워질 때까지 왼쪽으로 이동 된 복사본으로 반복하여 AND에 '비트 마스크에서 연속 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)

Pyth , 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

MATL , 10 바이트

2Y2imY'*X>

입력이 소문자입니다.

온라인으로 사용해보십시오!또는 모든 테스트 사례를 확인하십시오. .

이것은 @Sundar (구)와 @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

파이썬 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

온라인으로 사용해보십시오!

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.

TSQL (Microsoft SQL Server), 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';

입력이 모두 같은 경우 일 것으로 예상됩니다 (상단 또는 하한은 중요하지 않지만 대소 문자 혼합은 작동하지 않음).

언 골프 드 :

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 cte의 .

그런 다음 Runscte 에서 ASCII 코드로 변환하여 연속 문자 실행을 찾습니다 .

마지막으로 가장 큰 실행을 선택하고 select 문에 다시보고합니다.

C (gcc) , 58 56 바이트

@gastropner 덕분에 2 바이트 절약

내 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

C (gcc) , 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

온라인으로 사용해보십시오!

MATL , 12 10 바이트

91:wX-dX>q

온라인으로 사용해보십시오!

설명:

91:-1에서 91 사이의 숫자 목록을 만듭니다. 91은 문자 '['이며 'Z'뒤에옵니다. 따라서 이것은 '\ x1'에서 '['까지의 모든 문자 목록을 효과적으로 만듭니다. (우리는 주로 [ 'A'-1 :'Z '+ 1] 범위의 것을 원하지만 나머지는 아프지 않으며 바이트 수가 적습니다.)

w -암시 적 입력, 스택 상단으로 입력 가져 오기 ( 'TUTORIALS'가정)

X- -차이를 설정하십시오. 입력 문자열에 없는 문자 만 원래 순서대로 ( 'stable') 남습니다 . 스택:' !"#$%&'()*+,-./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

온라인으로 사용해보십시오!

K (ngn / k) , 17 15 바이트

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

온라인으로 사용해보십시오!

- 문자를 숫자로 변환하는 것만 있습니까 (음수인지는 중요하지 않습니다)

{ }\ 수렴까지 함수를 적용하여 중간 결과 유지

x+1 각 숫자에 1을 더하다 x

^ "without"-오른쪽 목록에서 요소가없는 왼쪽 목록

x^x^x+1x와 교차하는 수단x+1

1_ 첫 번째 요소를 삭제

# 카운트

레티 나 0.8.2 , 54 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

O`.

문자를 순서대로 정렬하십시오.

D`.

편지를 복제하십시오.

.
$&$&¶

각 문자를 별도의 줄에 복제하십시오.

T`l`_l`¶.

각 쌍의 첫 번째를 줄입니다.

(.)¶\1
$1

이 문자가 이전 문자와 일치하면 다시 결합하십시오.

.(.+)
$.1

모든 런의 길이를 센다.

O#^`

숫자를 역순으로 정렬하십시오.

1G`

첫 번째 (가장 큰)를 가져 가라.

J, 16 바이트

FrownyFrog 덕분에 -7 바이트

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

C (gcc) , 98 92 바이트

제안에 대한 Jonathan Frech에게 감사드립니다.

대문자 만.

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

온라인으로 사용해보십시오!

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

펄 5, 68 바이트

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

온라인으로 사용해보십시오 .

언 골프 드 :

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 바이트

입력에 소문자 만 포함한다고 가정합니다. 먼저 문자열을 반복하고 문자가 표시되는 비트를 정수로 설정합니다. 다음으로 정수에서 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;}

온라인으로 사용해보십시오!

Perl 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

온라인으로 사용해보십시오 .

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

언 골프 드 :

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 바이트

{⊇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: S는이다 deduplicated의 orted substring 입력의 대신 일부 부분 집합의 단지 일부 순열의.

하스켈 , 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 -}

파이썬 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])

온라인으로 사용해보십시오!

Pyth-11 바이트

le@.:G).:S{

입력은 따옴표로 묶어야합니다. 허용되지 않은 경우 :

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

코 틀린 , 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}()}

온라인으로 사용해보십시오!

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

포트 Arnauld 의 C의 대답 . 여기에서 온라인으로 사용해보십시오 .

언 골프 드 :

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 바이트

stdin에서 소문자를 읽고 stdout에 숫자를 출력합니다.

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