Граф последовательных персонажей

24

Для строки, содержащей только буквы, выведите длину самого длинного ряда последовательных букв алфавита, которое содержит слово, где порядок не имеет значения. Пример алгоритма может отсортировать слово, удалить дубликаты, а затем вывести длину самого длинного прогона.

Тестовые случаи

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

Например, antidisestablishmentarianismсодержит буквы abdehilmnstr. Самые длинные пробеги lmnи rst, как длины 3.

Заметки

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

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.

code-golf  string  alphabet 
— Стивен
источник
@ H.PWiz, я предполагаю, что это опечатка, и это должно быть rst- uniquify, сортировка и получить самый длинный пробег подряд. Можем ли мы принять ввод как массив символов?
— Лохматый
@ Shaggy да, определенно, я не включил это, потому что я думал, что это было по умолчанию
— Стивен
Является ли «a» смежным с «z» - должен ли «зебра» получить оценку 2 или 3?
— Джонатан Аллан
(... судя по вашему примеру алгоритма, я думаю, "нет" и "2")
— Джонатан Аллан
@JonathanAllan вы правы
— Стивен

Ответы:

10

Желе ,  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
— Джонатан Аллан
источник
8

R , 44 43 байта

Работает с массивом строчных букв. Изменить: изменил его с тестирования истинных значений на умножение на T / F для байта.

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

Попробуйте онлайн!

Выполняет ли кодирование длины серии букв, содержащихся в предоставленных символах, затем возвращает максимальное значение для истинных значений.

— MickyT
источник
Работал над аналогичным ролевым решением с использованием utf8ToInt, но брать массив строк намного умнее. +1
— JayCe
@JayCe Начал таким же образом, но потом понял, что проверка букв% в% позаботилась о шагах сортировки, уникальности и
— различия
7

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

-1 байт благодаря H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Попробуйте онлайн!

⍞ вводит строку

⎕a это прописные буквы английского алфавита

⎕a∊⍞ логический вектор длины 26 - какие буквы встречаются в строке?

⊆⍨ векторы формы последовательных 1с

≢⍉↑ смешать в матрицу, транспонировать и вернуть ее высоту - эффективно найти длину самого длинного вектора 1 с

— СПП
источник
1
⌈/≢¨->≢⍉↑
— H.PWiz
6

Perl 6 , 41 байт

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

Попробуй это

Expanded:

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

— Брэд Гилберт b2gills
источник
6

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)
— Arnauld
источник
5

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
— Sok
источник
Отличный метод, использующий тот факт, что подстроки упорядочены по длине!
— Джонатан Аллан
Это будет гораздо менее эффективно, но вы можете использовать yвместо .:.
— FryAmTheEggman
5

MATL , 10 байт

2Y2imY'*X>

Ввод в нижнем регистре.

Попробуйте онлайн! Или проверьте все тестовые случаи .

Здесь используется сочетание @ Sundar's (old) и @ ngn's подходов .

объяснение

Рассмотрим ввод '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
— Луис Мендо
источник
5

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

Попробуйте онлайн!

— XNOR
источник
Как насчет использования байтов python3 в качестве входных данных f=lambda s:s and-~f({*s}&{c+1for c in s})or 0?
— Винсент
5

05AB1E , 6 байтов

Œ...é→æ

êæAÃθg

Попробуйте онлайн!

Также 6 байтов

Сохранено 2 байта, опять же благодаря Adnan : 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.
— Мистер Xcoder
источник
Первая программа может быть в гольф, êæAÃ`gа вторая программа может быть в гольф ASåγOZ.
— Аднан
@ Adnan Спасибо, обновлено! Мне нравится ASåтрюк.
— г-н Xcoder
4

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

Ожидается, что входные данные имеют одинаковый регистр (верхний или нижний регистр не имеет значения, но смешанный регистр не будет работать).

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

Объяснение:

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

Затем находит последовательности последовательных букв путем преобразования в код ASCII в Runs cte.

Наконец, он выбирает самый большой прогон и отчитывается в операторе выбора.

— Брайан Дж
источник
Хороший ответ, очень хорошее использование CTE. Не уверен, поможет ли это или повредит вашему количеству байтов, но «одобренный» метод для получения ввода в T-SQL - это использование предварительно созданной таблицы .
— BradC
@BradC Если я могу взять таблицу с каждой строкой как один символ (вроде как массив символов вместо строки), то это поможет удалить один CTE. Если он все еще должен быть одной строкой, это, вероятно, примерно то же самое, что принимать его в качестве входной переменной. Спасибо за идею, хотя!
— Брайан Дж
4

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
— Arnauld
источник
Это конкретная реализация, которая 1<<*sоборачивает или это стандартное поведение?
— Джонатан Фрех
@JonathanFrech Я думаю, это официально неопределенное поведение. Так что это должно быть конкретной реализацией.
— Арно
Потому что достаточно интересно, что это выглядит только когда он вычисляется во время выполнения. При компиляции 1<<32результатов 0и выдает предупреждения размера типа данных.
— Джонатан Фрех
На самом деле, я сомневаюсь, что компилятор явно применил бы 5-битную маску. Скорее всего, это делается на уровне процессора.
— Арно
2
@Arnauld это так (см. Примечание: «[...] Операнд счета может быть непосредственным значением или регистром CL. Счет маскируется до 5 битов, что ограничивает диапазон счета от 0 до 31».)
— ErikF
3

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

Попробуйте онлайн!

— Джонатан Фрех
источник
+1 за "c, o, u; n (t, e, r)" :)
3

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

Попробуйте онлайн!

— sundar - Восстановить Монику
источник
Так много подходов :-)
— Луис Мендо
3

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

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

Попробуйте онлайн!

- есть только для преобразования символов в числа (не имеет значения, если они отрицательные)

{ }\ применяет функцию до сходимости, сохраняя промежуточные результаты

x+1 добавьте 1 к каждому числу в x

^ «без» - список слева без элементов, встречающихся в списке справа

x^x^x+1означает, что xпересекается сx+1

1_ отбросить первый элемент

# подсчитывать

— СПП
источник
#1_{x^x^x+1}\-?
— Адам
@ Adám да, однажды я должен заставить поезда работать ...
— нг
концептуализировать это как пересечение с приращением до сходимости довольно приятно
— Иона
поезда работают
— нгн
2

Сетчатка 0.8.2 , 54 байта

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Объяснение:

O`.

Сортировать буквы по порядку.

D`.

Дублируйте письма.

.
$&$&¶

Дублируйте каждую букву в отдельных строках.

T`l`_l`¶.

Уменьшить первую из каждой пары.

(.)¶\1
$1

Если теперь это соответствует предыдущему символу, соедините их вместе.

.(.+)
$.1

Подсчитайте длину всех трасс.

O#^`

Сортируйте их в обратном порядке.

1G`

Возьмите первый (самый большой).

— Нил
источник
2

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
— Ион
источник
Я думаю, что вы можете использовать ]вместо ~.@/:~алфавита уже отсортированы, поэтому вам не нужно сортировать входные данные и сохранять только уникальные элементы. TIO - 18 байт
— Гален Иванов
1
16
— FrownyFrog
@FrownyFrog и Гален, спасибо вам обоим! Оглядываясь назад, должно было быть очевидно, что сначала мне не нужен этот uniq / sort.
— Иона
2

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

Попробуйте онлайн!

— ErikF
источник
Вам на самом деле не нужно k;в конце. Неявное возвращение gcc является побочным эффектом присваивания переменной, который, по-видимому, выполняется как последний шаг в цикле for.
— Джонатан Фрех,
Возможные 95 байтов .
— Джонатан Фрех
@JonathanFrech Я не доверяю неявным возвращениям gcc. Они не всегда происходят так, как я от них ожидаю, и они часто вообще не работают для указателей и с плавающей точкой. К счастью, вне кодового гольфа я никогда ими не пользуюсь! :-)
— ErikF
2

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
— мохнатый
источник
@ Downvoter, не могли бы вы указать причину -1, пожалуйста?
— Лохматый
2

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

Попробуйте онлайн!

— gastropner
источник
2

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

Попробуйте онлайн .

— Денис Ибаев
источник
1
Хороший подход! Я бы вообще не рассматривал этот метод ... Вы можете сэкономить несколько байтов, используя -pFи -MList::Util+(max)перейти к 56: Попробуйте онлайн!
— Дом Гастингс
@DomHastings -MList::Util=maxдобавляет 16 байт к результату.
— Денис Ибаев
Если я правильно понимаю новую оценку, флаги командной строки не учитываются как байты, а как отдельно оцениваемый язык, так что вместо Perl он будет с Perl -MList::Util+(max) -pFили подобным. codegolf.meta.stackexchange.com/a/14339/9365
— Дом Гастингс,
2

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 );
— Мартин
источник
2

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

— sundar - Восстановить Монику
источник
1

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 -}
— Mego
источник
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)
                )
            )
        )
    )
)
— Tornado547
источник
1

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

Порт Арнаулда С ответ . Попробуйте это онлайн здесь .

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
}
— OOBalance
источник
1

> <> , 63 байта

Читает строчные символы из стандартного ввода, выводит число в стандартный вывод. 

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
— Саша
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.