Dada uma sequência que contém apenas letras, produza o comprimento da maior sequência de letras alfabéticas consecutivas que a palavra contém, em que a ordem não importa. Um algoritmo de exemplo pode classificar a palavra, remover duplicatas e gerar o comprimento da execução mais longa.

Casos de teste

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

Por exemplo, antidisestablishmentarianismcontém as letras abdehilmnstr. As corridas mais longas são lmne rst, ambas de comprimento 3.

Notas

Você pode usar todas as letras minúsculas, todas as maiúsculas ou maiúsculas como entrada, mas a caixa não pode codificar informações sobre a palavra (ou seja, você não pode colocar os primeiros ncaracteres em maiúsculas onde nestá o comprimento da execução mais longa).

Isso é código-golfe , então a resposta mais curta em bytes vence.

Geléia ,  10 9 8 7  6 bytes

OṬṣ0ZL

Experimente online!

^{9 estava usando o método de Sok :ṢQẆẇƇØaṪL}

Quão?

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 bytes

Funciona em uma matriz de caracteres minúsculos. Editar: mudou de teste de True valores para multiplicar pelo T / F para um byte.

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

Experimente online!

Uma codificação de comprimento de execução nas letras que estão nos caracteres fornecidos retorna o valor máximo para as verdades.

APL (Dyalog Classic) , 10 9 bytes

-1 byte graças a H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Experimente online!

⍞ insere uma string

⎕a é o alfabeto inglês maiúsculo

⎕a∊⍞ um vetor booleano length-26 - que letras ocorrem na string?

⊆⍨ formam vetores de 1s consecutivos

≢⍉↑ misture em uma matriz, transponha e retorne sua altura - efetivamente, encontre o comprimento do vetor mais longo de 1s

Perl 6 , 41 bytes

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

Teste-o

Expandido:

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

Dado 'stars', .ords.sort.squish Z-0..*retornaria(97,113,113,113)

Haskell , 35 bytes

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

Experimente online!

Haskell , 50 bytes

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

Experimente online!

JavaScript (Node.js) , 51 bytes

O caso da sequência de entrada não importa.

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

Experimente online!

Quão?

Primeiro convertemos a string de entrada em uma máscara de bits de letras encontradas com:

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

O deslocamento bit a bit é processado com um módulo implícito 32.

Exemplo:

"feedback" --> 100001111110
               kjihgfedcba-

Em seguida, 'reduzimos' as execuções de 1s consecutivos na máscara de bits repetidamente AND'ing com uma cópia de deslocamento à esquerda até que todos os bits sejam limpos:

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

O número de letras consecutivas em ordem alfabética é o número de iterações do processo acima. Daí a função recursiva:

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

Pitão , 9 bytes

le}#G.:S{

A entrada é assumida como uma sequência minúscula. Experimente online aqui ou verifique todos os casos de teste de uma vez aqui .

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 bytes

2Y2imY'*X>

A entrada está em minúscula.

Experimente online! Ou verifique todos os casos de teste .

Isso usa uma combinação das abordagens de @ Sundar (antiga) e de @ ngn .

Explicação

Considere a entrada 'tutorial'como um exemplo.

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 bytes

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

Experimente online!

Python 2 , 58 bytes

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

Experimente online!

Python 2 , 63 bytes

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

Experimente online!

05AB1E , 6 bytes

Œ...é$\to$ usando o conjunto de fontes embutido ( æ).

êæAÃθg

Experimente online!

Também 6 bytes

Economizou 2 bytes, novamente graças a Adnan : usando em ASåvez disso êÇ¥Θ, eliminando também a necessidade de aumentar o máximo no final. Veja o histórico de revisões para comparar os beviours dos dois métodos.

ASåγOà

Experimente online!

Como essas obras

Gosto de desafios como este, que levam a uma variedade de abordagens diferentes.

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

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

Para entrada, use a seguinte DECLAREinstrução antes do código:

DECLARE @ varchar(200) = 'propinquities';

Espera-se que a entrada seja do mesmo tipo (superior ou inferior não importa, mas maiúsculas e minúsculas não funcionariam).

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

Explicação:

Divide a sequência em uma linha para cada caractere (adaptado de /programming//a/27623321/1474939 ) noCTE cte.

Em seguida, localiza execuções de letras consecutivas convertendo para o código ASCII no Runs cte.

Por fim, ele seleciona a maior execução e os relatórios de volta na instrução select.

C (gcc) , 58 56 bytes

Guardado 2 bytes graças a @gastropner

Usa a mesma abordagem que a minha resposta Node.js . O caso da sequência de entrada não importa.

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

Experimente online!

Comentado

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 bytes

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

Experimente online!

Explicação

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

Experimente online!

MATL , 12 10 bytes

91:wX-dX>q

Experimente online!

Explicação:

91:- Crie a lista de números de 1 a 91. 91 é o caractere '[', que vem depois de 'Z'. Portanto, isso cria efetivamente a lista de todos os caracteres de '\ x1' a '['. (Nós queremos principalmente aqueles no intervalo ['A'-1:' Z '+ 1], mas ter o resto não dói e precisa de menos pelo número de dígitos).

w - Entrada implícita, coloque a entrada no topo da pilha (assuma 'TUTORIAIS')

X- - Definir diferença. Isso deixa apenas os caracteres que não foram encontrados na sequência de entrada, na ordem original ('stable'). Pilha:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Diferença entre elementos sucessivos nessa lista. Pilha:[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> - Obtenha o máximo dessas diferenças, ou seja, o número máximo de alfabetos consecutivos ausentes da diferença definida.

q - Decremento para obter a contagem real de caracteres

Mais velho:

12 bytes

Sud1=Y'*X>sQ

Experimente online!

K (ngn / k) , 17 15 bytes

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

Experimente online!

- existe apenas para converter os caracteres em números (não importa se são negativos)

{ }\ aplica uma função até a convergência, preservando resultados intermediários

x+1 adicione 1 a cada número em x

^ "sem" - a lista à esquerda sem elementos que ocorrem na lista à direita

x^x^x+1significa xinterseção comx+1

1_ solte o primeiro elemento

# contagem

Retina 0.8.2 , 54 bytes

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

Experimente online! O link inclui casos de teste. Explicação:

O`.

Classifique as letras em ordem.

D`.

Desduplicar as letras.

.
$&$&¶

Duplique cada letra em linhas separadas.

T`l`_l`¶.

Reduza o primeiro de cada par.

(.)¶\1
$1

Se isso agora corresponder ao personagem anterior, junte-os novamente.

.(.+)
$.1

Conte os comprimentos de todas as execuções.

O#^`

Classifique-os em ordem numérica inversa.

1G`

Pegue o primeiro (maior).

J, 16 bytes

-7 bytes graças ao FrownyFrog

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

Experimente online!

explicação

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

Obrigado a Jonathan Frech pelas sugestões.

Somente maiúsculas.

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

Experimente online!

Japt -h , 9 bytes

Não diferencia maiúsculas de minúsculas, recebe a entrada como uma sequência ou uma matriz de caracteres.

;CôkU mÊn

Experimente ou execute vários testes (a segunda linha serve como um substituto para o -hsinalizador, para que o sinalizador possa ser usado para processar várias entradas)

Explicação

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

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

Experimente online .

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 bytes

Assume que a entrada contém apenas letras minúsculas. Primeiro, ele circula a string e define os bits em um número inteiro, de acordo com o qual as letras são vistas. Em seguida, conta a sequência mais longa de 1 bits no número inteiro.

Edit: aé global, então será inicializado como 0 na primeira chamada. O segundo loop garante que seja redefinido para 0 antes de retornar. Portanto, podemos evitar redefini-lo manualmente.

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

Experimente online!

Perl 5, 62 + 2 ( -nFsinalizador) = 64 bytes

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

Experimente online .

Perl 5, 68 bytes

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

Experimente online .

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

Braquilog , 14 13 12 bytes

{⊇pS∧ẠsSl}ᶠ⌉

Experimente online!

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

Lento o suficiente para não terminar com o "antidisestablishmentarianism" de entrada no TIO. Um relativamente mais rápido para um byte de +1:

13 bytes

{dosS∧ẠsSl}ᶠ⌉

Experimente online!

Use dosem vez de ⊇p: S é um deduplicated s orted substring da entrada, em vez de apenas alguns permutação de algum subconjunto.

Haskell , 87 bytes

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

Experimente online!

Espera caracteres minúsculos

Explicação:

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 bytes

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

Experimente online!

Pitão - 11 bytes

le@.:G).:S{

A entrada deve estar entre aspas. Se não for permitido:

Pitão - 12 bytes

le@.:G).:S{z

Explicação:

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 bytes

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

Experimente online!

Java 8, 77 bytes

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

Resposta C do porto de Arnauld . Experimente online aqui .

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 bytes

Lê caracteres minúsculos de stdin, gera um número para stdout.

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

Experimente online!

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