Étant donné une chaîne contenant uniquement des lettres, affichez la longueur de la plus longue série de lettres alphabétiques consécutives que le mot contient, où l'ordre n'a pas d'importance. Un exemple d'algorithme peut trier le mot, supprimer les doublons, puis afficher la longueur de la plus longue exécution.

Cas de test

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

Par exemple, antidisestablishmentarianismcontient les lettres abdehilmnstr. Les parcours les plus longs sont lmnetrst , tous deux de longueur 3.

Remarques

Vous pouvez prendre toutes les lettres minuscules, toutes les majuscules ou les majuscules en entrée, mais la casse ne peut pas coder les informations sur le mot (c'est-à-dire que vous ne pouvez pas mettre les premiers ncaractères en majuscule oùn est la longueur de la plus longue exécution).

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

Gelée ,  10 9 8 7  6 octets

OṬṣ0ZL

Essayez-le en ligne!

^{9 utilisait la méthode de Sok :ṢQẆẇƇØaṪL}

Comment?

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 octets

Fonctionne sur un tableau de caractères minuscules. Modifier: il est passé du test des valeurs vraies à la multiplication par le T / F pour un octet.

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

Essayez-le en ligne!

Est-ce qu'un codage de longueur d'exécution sur les lettres qui sont dans les caractères fournis retourne ensuite la valeur maximale pour les vrais.

APL (Dyalog Classic) , 10 9 octets

-1 octet grâce à H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Essayez-le en ligne!

⍞ saisit une chaîne

⎕a est l'alphabet anglais majuscule

⎕a∊⍞ un vecteur booléen de longueur 26 - quelles lettres apparaissent dans la chaîne?

⊆⍨ former des vecteurs de 1 consécutifs

≢⍉↑ mélanger dans une matrice, transposer et retourner sa hauteur - trouver efficacement la longueur du vecteur le plus long de 1s

Perl 6 , 41 octets

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

Essaye-le

Étendu:

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

Étant donné 'stars', .ords.sort.squish Z-0..*reviendrait(97,113,113,113)

Haskell , 35 octets

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

Essayez-le en ligne!

Haskell , 50 octets

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

Essayez-le en ligne!

JavaScript (Node.js) , 51 octets

La casse de la chaîne d'entrée n'a pas d'importance.

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

Essayez-le en ligne!

Comment?

Nous convertissons d'abord la chaîne d'entrée en un masque de bits de lettres rencontrées avec:

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

Le décalage au niveau du bit est traité avec un modulo implicite 32.

Exemple:

"feedback" --> 100001111110
               kjihgfedcba-

Nous `` réduisons '' ensuite les exécutions de 1 consécutifs dans le masque binaire en le répétant ET `` avec une copie décalée à gauche de lui-même jusqu'à ce que tous les bits soient effacés:

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

Le nombre de lettres consécutives dans l'ordre alphabétique est le nombre d'itérations du processus ci-dessus. D'où la fonction récursive:

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

Pyth , 9 octets

le}#G.:S{

L'entrée est supposée être une chaîne en minuscules. Essayez-le en ligne ici ou vérifiez tous les cas de test en même temps ici .

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 octets

2Y2imY'*X>

L'entrée est en minuscules.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Cela utilise un mélange des approches de @ Sundar (ancienne) et @ ngn .

Explication

Considérez la saisie 'tutorial'comme exemple.

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 octets

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

Essayez-le en ligne!

Python 2 , 58 octets

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

Essayez-le en ligne!

Python 2 , 63 octets

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

Essayez-le en ligne!

05AB1E , 6 octets

1 octet sauvé grâce à Adnan : prise des sous-chaînes contiguës, puis tri par longueur ( Œ...é)$\to$en utilisant le jeu de puissance intégré à la place ( æ).

êæAÃθg

Essayez-le en ligne!

Aussi 6 octets

Sauvegardé 2 octets, encore une fois grâce à Adnan : utiliser à la ASåplace êÇ¥Θ, supprimant ainsi la nécessité d'incrémenter le maximum à la fin. Consultez l'historique des révisions pour comparer les comportements des deux méthodes.

ASåγOà

Essayez-le en ligne!

Comment ça marche

J'aime les défis comme celui-ci qui mènent à une variété d'approches différentes.

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

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

Pour la saisie, utilisez l' DECLAREinstruction suivante avant le code:

DECLARE @ varchar(200) = 'propinquities';

On s'attend à ce que l'entrée soit dans le même cas (le haut ou le bas n'a pas d'importance, mais le casse mixte ne fonctionnerait pas).

Non 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

Explication:

Divise la chaîne en une ligne pour chaque caractère (adapté de /programming//a/27623321/1474939 ) dans leCTE cte.

Puis, recherche des séries de lettres consécutives en les convertissant en code ASCII dans le Runscte.

Enfin, il sélectionne la plus grande exécution et rend compte dans l'instruction select.

C (gcc) , 58 56 octets

Sauvegardé 2 octets grâce à @gastropner

Utilise la même approche que ma réponse Node.js . La casse de la chaîne d'entrée n'a pas d'importance.

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

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Explication

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

Essayez-le en ligne!

MATL , 12 10 octets

91:wX-dX>q

Essayez-le en ligne!

Explication:

91:- Créez la liste des nombres de 1 à 91. 91 est le caractère «[», qui vient après «Z». Ainsi, cela crée effectivement la liste de tous les caractères de '\ x1' à '['. (Nous voulons principalement ceux de la gamme ['A'-1:' Z '+ 1], mais avoir le reste ne fait pas de mal et nécessite moins de bytecount.)

w - Entrée implicite, placez l'entrée en haut de la pile (supposez 'TUTORIELS')

X- - Réglez la différence. Cela ne laisse que les caractères qui n'ont pas été trouvés dans la chaîne d'entrée, dans leur ordre d'origine («stable»). Empiler:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Différence entre les éléments successifs de cette liste. Empiler:[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> - Obtenez le maximum de ces différences, c'est-à-dire le nombre maximum d'alphabets consécutifs manquants dans la différence définie.

q - Décrémenter pour obtenir le nombre réel de caractères

Plus âgée:

12 octets

Sud1=Y'*X>sQ

Essayez-le en ligne!

K (ngn / k) , 17 15 octets

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

Essayez-le en ligne!

- est là uniquement pour convertir les caractères en nombres (peu importe s'ils sont négatifs)

{ }\ applique une fonction jusqu'à la convergence, préservant les résultats intermédiaires

x+1 ajouter 1 à chaque numéro x

^ "sans" - la liste de gauche sans éléments apparaissant dans la liste de droite

x^x^x+1signifie xintersecté avecx+1

1_ déposer le premier élément

# compter

Retina 0.8.2 , 54 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

O`.

Triez les lettres dans l'ordre.

D`.

Dédupliquez les lettres.

.
$&$&¶

Dupliquez chaque lettre sur des lignes distinctes.

T`l`_l`¶.

Diminuez le premier de chaque paire.

(.)¶\1
$1

Si cela correspond maintenant au personnage précédent, réunissez-les à nouveau.

.(.+)
$.1

Comptez les longueurs de toutes les courses.

O#^`

Triez-les dans l'ordre numérique inverse.

1G`

Prenez le premier (le plus grand).

J, 16 octets

-7 octets grâce à FrownyFrog

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

Essayez-le en ligne!

explication

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

Merci à Jonathan Frech pour les suggestions.

Uniquement en majuscules.

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

Essayez-le en ligne!

Japt -h , 9 octets

Insensible à la casse, prend l'entrée sous la forme d'une chaîne ou d'un tableau de caractères.

;CôkU mÊn

Essayez-le ou exécutez plusieurs tests (la deuxième ligne sert de remplacement pour l' -hindicateur afin que l'indicateur puisse être utilisé pour traiter plusieurs entrées à la place)

Explication

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

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

Essayez-le en ligne .

Non 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 octets

Suppose que l'entrée ne contient que des lettres minuscules. Tout d'abord, il boucle sur la chaîne et définit les bits dans un entier en fonction des lettres visibles. Ensuite, il compte la séquence la plus longue de 1 bit dans l'entier.

Edit: aest global, il sera donc initialisé à 0 lors du premier appel. La deuxième boucle s'assure qu'elle est remise à 0 avant de revenir. Par conséquent, nous pouvons éviter de le réinitialiser manuellement.

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

Essayez-le en ligne!

Perl 5, 62 + 2 ( -nFindicateur) = 64 octets

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

Essayez-le en ligne .

Perl 5, 68 octets

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

Essayez-le en ligne .

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

Non 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 octets

{⊇pS∧ẠsSl}ᶠ⌉

Essayez-le en ligne!

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

Assez lent pour qu'il ne se termine pas pour l'entrée "antidisestablishmentarianism" sur TIO. Relativement beaucoup plus rapide pour +1 octet:

13 octets

{dosS∧ẠsSl}ᶠ⌉

Essayez-le en ligne!

Utiliser à la dosplace de ⊇p: S est une sous- dchaîne oéditée srépliquée de l'entrée, au lieu d'une simple permutation d'un sous-ensemble.

Haskell , 87 octets

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

Essayez-le en ligne!

Attend des caractères minuscules

Explication:

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 octets

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

Essayez-le en ligne!

Pyth - 11 octets

le@.:G).:S{

L'entrée doit être entourée de guillemets. Si non autorisé:

Pyth - 12 octets

le@.:G).:S{z

Explication:

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 octets

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

Essayez-le en ligne!

Java 8, 77 octets

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

Port de Arnauld de C réponse . Essayez-le en ligne ici .

Non 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 octets

Lit les caractères en minuscules de stdin, envoie un nombre à stdout.

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

Essayez-le en ligne!

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