Biorąc pod uwagę ciąg znaków zawierający tylko litery, wypisz długość najdłuższego ciągu kolejnych liter alfabetu, które zawiera słowo, w przypadku gdy kolejność nie ma znaczenia. Przykładowy algorytm może sortować słowo, usuwać duplikaty, a następnie wyświetlać długość najdłuższego przebiegu.

Przypadki testowe

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

Na przykład antidisestablishmentarianismzawiera literyabdehilmnstr . Najdłuższe przebiegi to lmni rstoba o długości 3.

Notatki

Jako dane wejściowe możesz wziąć wszystkie małe, wszystkie wielkie lub małe litery, ale wielkość liter nie może zakodować informacji o tym słowie (tzn. Nie możesz wpisać nwielkich liter, gdyn jest długość najdłuższego ciągu).

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

Galaretka ,  10 9 8 7  6 bajtów

OṬṣ0ZL

Wypróbuj online!

^{9 używał metody Sok :ṢQẆẇƇØaṪL}

W jaki sposób?

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 bajtów

Działa na szeregu małych liter. Edycja: zmieniono z testowania wartości True na pomnożenie przez T / F bajtu.

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

Wypróbuj online!

Wykonuje kodowanie długości przebiegu dla liter, które są w dostarczonych znakach, a następnie zwraca maksymalną wartość dla prawd.

APL (Dyalog Classic) , 10 9 bajtów

-1 bajt dzięki H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Wypróbuj online!

⍞ wprowadza ciąg

⎕a jest wielką literą alfabetu angielskiego

⎕a∊⍞ wektor boolowski o długości 26 - które litery występują w ciągu?

⊆⍨ tworzą wektory kolejnych 1s

≢⍉↑ wmieszaj w macierz, transponuj i zwróć jej wysokość - skutecznie znajdź długość najdłuższego wektora 1s

Perl 6 , 41 bajtów

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

Sprawdź to

Rozszerzony:

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

Biorąc pod uwagę 'stars', .ords.sort.squish Z-0..*wróci(97,113,113,113)

Haskell , 35 bajtów

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

Wypróbuj online!

Haskell , 50 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 51 bajtów

Wielkość ciągu wejściowego nie ma znaczenia.

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

Wypróbuj online!

W jaki sposób?

Najpierw konwertujemy ciąg wejściowy na maskę bitów napotkanych liter za pomocą:

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

Przesunięcie bitowe jest przetwarzane za pomocą niejawnego modułu 32.

Przykład:

"feedback" --> 100001111110
               kjihgfedcba-

Następnie „zmniejszamy” przebiegi kolejnych 1 w masce bitowej, wielokrotnie ORAZ ustawiając ją za pomocą przesuniętej w lewo kopii samej siebie, aż wszystkie bity zostaną usunięte:

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

Liczba kolejnych liter w kolejności alfabetycznej jest liczbą iteracji powyższego procesu. Stąd funkcja rekurencyjna:

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

Pyth , 9 bajtów

le}#G.:S{

Przyjmuje się, że wejście jest ciągiem małych liter. Wypróbuj on-line tutaj , lub sprawdzić wszystkie przypadki testowe od razu tutaj .

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 bajtów

2Y2imY'*X>

Dane wejściowe są pisane małymi literami.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wykorzystuje to połączenie podejść @ Sundar (stary) i @ ngn .

Wyjaśnienie

Rozważ dane wejściowe 'tutorial'jako przykład.

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 bajtów

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

Wypróbuj online!

Python 2 , 58 bajtów

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

Wypróbuj online!

Python 2 , 63 bajty

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

Wypróbuj online!

05AB1E , 6 bajtów

Œ...é$\to$æ

êæAÃθg

Wypróbuj online!

Również 6 bajtów

Zaoszczędzono 2 bajty, ponownie dzięki Adnanowi : użycie ASåzamiast tego êÇ¥Θ, eliminując w ten sposób potrzebę zwiększania maksimum na końcu. Zobacz historię zmian, aby porównać zachowanie obu metod.

ASåγOà

Wypróbuj online!

Jak to działa

Lubię takie wyzwania, które prowadzą do różnych podejść.

êæ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 bajtów

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

Do wprowadzenia użyj następującej DECLAREinstrukcji przed kodem:

DECLARE @ varchar(200) = 'propinquities';

Oczekuje się, że dane wejściowe są identyczne (górna lub dolna nie ma znaczenia, ale mieszane wielkości nie będą działać).

Nie golfowany:

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

Wyjaśnienie:

Dzieli ciąg na wiersz dla każdego znaku (dostosowany z /programming//a/27623321/1474939 ) wCTE cte.

Następnie znajduje ciągi kolejnych liter, konwertując na kod ASCII w Runscte.

Na koniec wybiera największy przebieg i raportuje z powrotem w instrukcji select.

C (gcc) , 58 56 bajtów

Zaoszczędź 2 bajty dzięki @gastropner

Wykorzystuje takie samo podejście jak mój node.js odpowiedź . Wielkość liter wejściowych nie ma znaczenia.

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

Wypróbuj online!

Skomentował

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Wypróbuj online!

MATL , 12 10 bajtów

91:wX-dX>q

Wypróbuj online!

Wyjaśnienie:

91:- Utwórz listę cyfr od 1 do 91. 91 to znak „[”, który występuje po „Z”. Skutecznie tworzy to listę wszystkich znaków od „\ x1” do „[”. (Chcemy głównie tych z zakresu [„A'-1:„ Z ”+ 1]), ale reszta nie boli i wymaga mniejszej liczby bajtów.)

w - Implikowane dane wejściowe, wprowadź dane wejściowe na szczyt stosu (załóż „ĆWICZENIA”)

X- - Ustaw różnicę. Pozostawia to tylko znaki, których nie znaleziono w ciągu wejściowym, w ich oryginalnej kolejności („stabilna”). Stos:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Różnica między kolejnymi elementami na tej liście. Stos:[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> - Uzyskaj maksimum tych różnic, tj. Maksymalną liczbę kolejnych alfabetów brakujących w ustawionej różnicy.

q - Zmniejszenie, aby uzyskać rzeczywistą liczbę znaków

Starsze:

12 bajtów

Sud1=Y'*X>sQ

Wypróbuj online!

K (ngn / k) , 17 15 bajtów

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

Wypróbuj online!

- czy istnieje tylko konwersja znaków na liczby (nie ma znaczenia, czy są one ujemne)

{ }\ stosuje funkcję aż do konwergencji, zachowując wyniki pośrednie

x+1 dodaj 1 do każdego numeru w x

^ „bez” - lista po lewej bez elementów, które występują na liście po prawej stronie

x^x^x+1oznacza xprzecięty zx+1

1_ upuść pierwszy element

# liczyć

Retina 0.8.2 , 54 bajty

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

Wypróbuj online!Link zawiera przypadki testowe. Wyjaśnienie:

O`.

Sortuj litery w kolejności.

D`.

Deduplikuj litery.

.
$&$&¶

Duplikuj każdą literę w osobnych wierszach.

T`l`_l`¶.

Zmniejsz pierwszą z każdej pary.

(.)¶\1
$1

Jeśli teraz pasuje do poprzedniej postaci, połącz je ponownie.

.(.+)
$.1

Policz długości wszystkich przebiegów.

O#^`

Posortuj je w odwrotnej kolejności numerycznej.

1G`

Weź pierwszą (największą).

J, 16 bajtów

-7 bajtów dzięki FrownyFrog

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

Wypróbuj online!

wyjaśnienie

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

Podziękowania dla Jonathana Frecha za sugestie.

Tylko wielkie litery.

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

Wypróbuj online!

Japt -h , 9 bajtów

Case insenstive, przyjmuje dane wejściowe jako ciąg znaków lub tablicę znaków.

;CôkU mÊn

Wypróbuj lub uruchom wiele testów (drugi wiersz służy jako zamiennik -hflagi, aby zamiast tego można było użyć flagi do przetwarzania wielu danych wejściowych)

Wyjaśnienie

              :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 bajtów

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

Wypróbuj online .

Nie golfowany:

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 bajtów

Zakłada, że ​​dane wejściowe zawierają tylko małe litery. Najpierw zapętla się nad łańcuchem i ustawia bity w liczbie całkowitej, zgodnie z którymi widoczne są litery. Następnie zlicza najdłuższą serię 1 bitów w liczbie całkowitej.

Edycja: ajest globalna, więc przy pierwszym wywołaniu zostanie zainicjowana na 0. Druga pętla upewnia się, że jest resetowana do 0 przed powrotem. Dlatego możemy uniknąć resetowania go ręcznie.

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

Wypróbuj online!

Perl 5, 62 + 2 ( -nFflaga) = 64 bajty

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

Wypróbuj online .

Perl 5, 68 bajtów

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

Wypróbuj 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);

Nie golfowany:

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 bajtów

{⊇pS∧ẠsSl}ᶠ⌉

Wypróbuj 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

Na tyle powolny, że nie kończy się na wprowadzeniu „antydestablishmentarianism” na TIO. Relatywnie dużo szybszy dla 1 bajtu:

13 bajtów

{dosS∧ẠsSl}ᶠ⌉

Wypróbuj online!

Używać doszamiast ⊇pS jest deduplicated s orted substring wprowadzania, a nie tylko niektóre permutacji pewnego podzbioru.

Haskell , 87 bajtów

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

Wypróbuj online!

Oczekuje małych liter

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Pyth - 11 bajtów

le@.:G).:S{

Dane wejściowe muszą być ujęte w cudzysłów. Jeśli nie wolno:

Pyth - 12 bajtów

le@.:G).:S{z

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Java 8, 77 bajtów

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

Odpowiedź C z Port of Arnauld . Wypróbuj online tutaj .

Nie golfowany:

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 bajty

Odczytuje małe litery ze standardowego wejścia, wypisuje liczbę na standardowe wyjście.

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

Wypróbuj 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