Враховуючи рядок, що містить лише літери, виведіть довжину найдовшого циклу послідовних буквених букв, яке містить слово, де порядок не має значення. Прикладний алгоритм може сортувати слово, видаляти дублікати та виводити довжину найдовшого пробігу.

Випробування

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

Наприклад, antidisestablishmentarianismмістить букви abdehilmnstr. Найдовші пробіги - lmnі rstобидві довжиною 3.

Примітки

Ви можете взяти всі вхідні, великі і великі літери як вхідні, але регістр не може кодувати інформацію про слово (тобто ви не можете зробити перші nсимволи з великої літери, де nдовжина найдовшого пробігу).

Це код-гольф , тому найкоротша відповідь у байтах виграє.

Желе ,  10 9 8 7  6 байт

OṬṣ0ZL

Спробуйте в Інтернеті!

^{9 використовував метод Сока :Ṣ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 байт

Працює на масиві малих символів. Редагувати: змінив її від тестування істинних значень до множення на T / F на байт.

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

Спробуйте в Інтернеті!

Чи кодує довжину запуску на літери, що містяться в наданих символах, потім повертає максимальне значення для прав.

APL (Dyalog Classic) , 10 9 байт

-1 байт завдяки H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Спробуйте в Інтернеті!

⍞ вводить рядок

⎕a є великим англійським алфавітом

⎕a∊⍞ булева довжина-26 вектор - які букви зустрічаються в рядку?

⊆⍨ утворюють вектори послідовних 1с

≢⍉↑ змішайте в матрицю, перенесіть і поверніть її висоту - ефективно знайдіть довжину найдовшого вектора 1s

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

Haskell , 35 байт

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

Спробуйте в Інтернеті!

Haskell , 50 байт

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

Спробуйте в Інтернеті!

JavaScript (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-

Потім ми «зменшуємо» прогони послідовних 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>

Введіть малі літери.

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

При цьому використовується поєднання @ Сундара х (старий) і @ СПП - х підходів.

Пояснення

Розглянемо вклад '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

Python 3 , 55 байт

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

Спробуйте в Інтернеті!

Python 2 , 58 байт

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

Спробуйте в Інтернеті!

Python 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

Пояснення:

Розбиває рядок на рядок aa для кожного символу (адаптованого з /programming//a/27623321/1474939 ) у CTEcte.

Потім знаходить прогони послідовних букв шляхом перетворення в ASCII код у Runscte.

Нарешті, він вибирає найбільший запуск і звітує про це у операторі select.

C (gcc) , 58 56 байт

Збережено 2 байти завдяки @gastropner

Використовує той же підхід, що й мій 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 - Неявне введення, підведіть вхід до вершини стеку (припустимо "НАВЧАЛИ")

X- - Встановити різницю. При цьому залишаються лише символи, які не були знайдені у рядку введення, у їх первісному порядку ("стабільний"). Стек:' !"#$%&'()*+,-./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

Спробуйте в Інтернеті!

К (нг / к) , 17 15 байт

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

Спробуйте в Інтернеті!

- чи є лише перетворення символів у числа (не має значення, чи вони негативні)

{ }\ застосовує функцію до конвергенції, зберігаючи проміжні результати

x+1 додайте 1 до кожного числа в x

^ "без" - список зліва без елементів, які трапляються у списку праворуч

x^x^x+1засоби, що xперетинаються з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 байт

-7 байт завдяки FrownyFrog

[:>./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 байт

Дякую Джонатану Фреху за пропозиції.

Лише великі регістри

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

Perl 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

Спробуйте в Інтернеті .

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

Брахілог , 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 входу, а НЕ тільки деякою перестановкою деякого підмножини.

Haskell , 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 -}

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

Спробуйте в Інтернеті!

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

Порт Арно C «s відповідь . Спробуйте його онлайн тут .

Безголівки:

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