Dada una cadena que contiene solo letras, genera la longitud de la ejecución más larga de letras alfabéticas consecutivas que contiene la palabra, donde el orden no importa. Un algoritmo de ejemplo puede ordenar la palabra, eliminar duplicados y luego generar la duración de la ejecución más larga.

Casos de prueba

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

Por ejemplo, antidisestablishmentarianismcontiene las letras abdehilmnstr. Las carreras más largas son lmny rst, ambas de longitud 3.

Notas

Puede tomar todas las letras minúsculas, mayúsculas o mayúsculas como entrada, pero el caso no puede codificar información sobre la palabra (es decir, no puede poner en nmayúscula los primeros caracteres donde nestá la longitud de la ejecución más larga).

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

Gelatina ,  10 9 8 7  6 bytes

OṬṣ0ZL

Pruébalo en línea!

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

¿Cómo?

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 en una matriz de caracteres en minúsculas. Editar: cambió de probar los valores verdaderos a multiplicar por el T / F para un byte.

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

Pruébalo en línea!

Hace una codificación de longitud de ejecución en letras que están en los caracteres suministrados y luego devuelve el valor máximo para las verdades.

APL (Dyalog Classic) , 10 9 bytes

-1 byte gracias a H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Pruébalo en línea!

⍞ ingresa una cadena

⎕a es el alfabeto en mayúscula

⎕a∊⍞ un vector booleano de longitud 26: ¿qué letras aparecen en la cadena?

⊆⍨ forman vectores de 1s consecutivos

≢⍉↑ mezclar en una matriz, transponer y devolver su altura; efectivamente, encuentre la longitud del vector más largo de 1s

Perl 6 , 41 bytes

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

Pruébalo

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..*volvería(97,113,113,113)

Haskell , 35 bytes

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

Pruébalo en línea!

Haskell , 50 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 51 bytes

El caso de la cadena de entrada no importa.

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

Pruébalo en línea!

¿Cómo?

Primero convertimos la cadena de entrada en una máscara de bits de letras encontradas con:

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

El desplazamiento a nivel de bits se procesa con un módulo implícito 32.

Ejemplo:

"feedback" --> 100001111110
               kjihgfedcba-

Luego 'reducimos' las corridas de 1 consecutivos en la máscara de bits Y repetidamente Y 'con una copia desplazada a la izquierda de sí mismo hasta que se borren todos los bits:

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

El número de letras consecutivas en orden alfabético es el número de iteraciones del proceso anterior. De ahí la función recursiva:

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

Pyth , 9 bytes

le}#G.:S{

Se supone que la entrada es una cadena en minúsculas. Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

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>

La entrada está en minúsculas.

Pruébalo en línea! O verificar todos los casos de prueba .

Utiliza una combinación de los enfoques de @ Sundar (antiguo) y @ ngn .

Explicación

Considere la entrada 'tutorial'como un ejemplo.

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

Pruébalo en línea!

Python 2 , 58 bytes

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

Pruébalo en línea!

Python 2 , 63 bytes

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

Pruébalo en línea!

05AB1E , 6 bytes

Œ...é$\to$æ

êæAÃθg

Pruébalo en línea!

También 6 bytes

Ahorré 2 bytes, nuevamente gracias a Adnan : usando en su ASålugar êÇ¥Θ, eliminando así la necesidad de incrementar el máximo al final. Consulte el historial de revisiones para comparar los comportamientos de los dos métodos.

ASåγOà

Pruébalo en línea!

Cómo funcionan

Me gustan los desafíos como este que conducen a una variedad de enfoques 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 la entrada, use la siguiente DECLAREdeclaración antes del código:

DECLARE @ varchar(200) = 'propinquities';

Se espera que la entrada sea todo lo mismo (mayúsculas o minúsculas no importa, pero las mayúsculas y minúsculas no funcionarían).

Sin golf:

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

Explicación:

Divide la cadena en una fila para cada carácter (adaptado de /programming//a/27623321/1474939 ) en el CTEcte.

Luego, encuentra corridas de letras consecutivas convirtiéndolas al código ASCII en Runs cte.

Por último, selecciona la ejecución más grande e informa en la declaración de selección.

C (gcc) , 58 56 bytes

Guardado 2 bytes gracias a @gastropner

Utiliza el mismo enfoque que mi respuesta Node.js . El caso de la cadena de entrada no importa.

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

Pruébalo en línea!

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

MATL , 12 10 bytes

91:wX-dX>q

Pruébalo en línea!

Explicación:

91:- Cree la lista de números del 1 al 91. 91 es el carácter '[', que viene después de 'Z'. Entonces, esto crea efectivamente la lista de todos los caracteres desde '\ x1' hasta '[' '. (Queremos principalmente aquellos en el rango ['A'-1:' Z '+ 1], pero tener el resto no hace daño y necesita menos recuento).

w - Entrada implícita, llevar la entrada a la parte superior de la pila (suponga 'TUTORIALES')

X- - Establecer diferencia. Esto deja solo los caracteres que no se encontraron en la cadena de entrada, en su orden original ('estable'). Apilar:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Diferencia entre elementos sucesivos en esa lista. Apilar:[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> - Obtenga el máximo de esas diferencias, es decir, el número máximo de alfabetos consecutivos que faltan en la diferencia establecida.

q - Disminuir para obtener el recuento de caracteres real

Más viejo:

12 bytes

Sud1=Y'*X>sQ

Pruébalo en línea!

K (ngn / k) , 17 15 bytes

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

Pruébalo en línea!

- solo existe para convertir los caracteres en números (no importa si son negativos)

{ }\ aplica una función hasta la convergencia, preservando resultados intermedios

x+1 agregue 1 a cada número en x

^ "sin": la lista de la izquierda sin elementos que aparecen en la lista de la derecha

x^x^x+1significa xintersectado conx+1

1_ soltar el primer elemento

# contar

Retina 0.8.2 , 54 bytes

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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

O`.

Ordena las letras en orden.

D`.

Deduplicar las letras.

.
$&$&¶

Duplica cada letra en líneas separadas.

T`l`_l`¶.

Disminuye el primero de cada par.

(.)¶\1
$1

Si esto ahora coincide con el personaje anterior, únelos nuevamente.

.(.+)
$.1

Cuente las longitudes de todas las carreras.

O#^`

Ordénelos en orden numérico inverso.

1G`

Tome el primero (el más grande).

J, 16 bytes

-7 bytes gracias a FrownyFrog

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

Pruébalo en línea!

explicación

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

Gracias a Jonathan Frech por las sugerencias.

Solo mayú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);}

Pruébalo en línea!

Japt -h , 9 bytes

No distingue entre mayúsculas y minúsculas, toma la entrada como una cadena o una matriz de caracteres.

;CôkU mÊn

Pruébelo o ejecute varias pruebas (la segunda línea sirve como un reemplazo para el -hindicador, por lo que el indicador puede usarse para procesar múltiples entradas)

Explicación

              :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$.

Pruébalo en línea .

Sin golf:

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

Asume que la entrada solo contiene letras minúsculas. Primero, recorre la cadena y establece bits en un número entero según las letras que se ven. A continuación, cuenta la racha más larga de 1 bits en el entero.

Editar: aes global, por lo que se inicializará a 0 en la primera llamada. El segundo bucle asegura que se restablezca a 0 antes de regresar. Por lo tanto, podemos evitar reiniciarlo manualmente.

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

Pruébalo en línea!

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

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

Pruébalo en línea .

Perl 5, 68 bytes

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

Pruébalo en línea .

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

Sin golf:

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 bytes

{⊇pS∧ẠsSl}ᶠ⌉

Pruébalo en línea!

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

Lo suficientemente lento como para que no termine la entrada "antidisestablishmentarianism" en TIO. Uno relativamente más rápido para +1 byte:

13 bytes

{dosS∧ẠsSl}ᶠ⌉

Pruébalo en línea!

Usar dosen lugar de ⊇p: S es un deduplicated s orted substring de la entrada, en lugar de alguna permutación de algún subconjunto.

Haskell , 87 bytes

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

Pruébalo en línea!

Espera caracteres en minúsculas

Explicación:

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

Pruébalo en línea!

Pyth - 11 bytes

le@.:G).:S{

La entrada debe estar entre comillas. Si no está permitido:

Pyth - 12 bytes

le@.:G).:S{z

Explicación:

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

Pruébalo en línea!

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

La respuesta C del puerto de Arnauld . Pruébelo en línea aquí .

Sin golf:

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

Lee caracteres en minúsculas de stdin, genera un número en stdout.

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

Pruébalo en línea!

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