Conta personaggi consecutivi

24

Data una stringa contenente solo lettere, genera la lunghezza della sequenza più lunga di lettere alfabetiche consecutive contenute nella parola, dove l'ordine non ha importanza. Un algoritmo di esempio può ordinare la parola, rimuovere i duplicati e quindi generare la lunghezza della corsa più lunga.

Casi test

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

Ad esempio, antidisestablishmentarianismcontiene le lettere abdehilmnstr. Le piste più lunghe sono lmne rst, entrambe di lunghezza 3.

Gli appunti

Puoi prendere tutte le lettere minuscole, maiuscole o maiuscole come input, ma il caso non può codificare le informazioni sulla parola (cioè non puoi rendere i primi ncaratteri in maiuscolo dove nè la lunghezza della corsa più lunga).

Questo è code-golf , quindi vince la risposta più breve in byte.

code-golf  string  alphabet 
— Stefano
fonte
@ H.PWiz, suppongo che sia un errore di battitura e dovrebbe essere rst- unificare, ordinare e ottenere la corsa consecutiva più lunga. Possiamo prendere l'input come una matrice di caratteri?
— Shaggy,
@Shaggy sì, sicuramente, non l'ho incluso perché pensavo fosse un valore predefinito
— Stephen,
"A" è adiacente a "z" - la "zebra" dovrebbe segnare 2 o 3?
— Jonathan Allan,
(... a giudicare dal tuo algoritmo di esempio immagino "no" e "2")
— Jonathan Allan,
@JonathanAllan hai ragione
— Stephen,

Risposte:

10

Gelatina ,  10 9 8 7  6 byte

OṬṣ0ZL

Provalo online!

9 stava usando il metodo di Sok :ṢQẆẇƇØaṪL

Come?

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
— Jonathan Allan
fonte
8

R , 44 43 byte

Funziona su una matrice di caratteri minuscoli. Modifica: modificato dal test dei valori Veri alla moltiplicazione per il T / F per un byte.

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

Provalo online!

Esegue una codifica della lunghezza delle lettere che si trovano nei caratteri forniti, quindi restituisce il valore massimo per i valori.

— MickyT
fonte
Stavo lavorando su una soluzione simile usando utf8ToInt, ma prendere una matrice di stringhe è molto più intelligente. +1
— JayCe,
@JayCe È iniziato allo stesso modo, ma poi si è reso conto che un controllo% in% delle lettere si occupava dei passaggi di ordinamento, unico e diff in un colpo solo
— MickyT
7

APL (Dyalog Classic) , 10 9 byte

-1 byte grazie a H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Provalo online!

⍞ inserisce una stringa

⎕a è l'alfabeto inglese maiuscolo

⎕a∊⍞ un vettore booleano di lunghezza 26 - quali lettere compaiono nella stringa?

⊆⍨ forma vettori di 1s consecutivi

≢⍉↑ mescolare in una matrice, trasporre e restituire la sua altezza - in modo efficace, trovare la lunghezza del vettore più lungo di 1 s

— NGN
fonte
1
⌈/≢¨->≢⍉↑
— H.Piz,
6

Perl 6 , 41 byte

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

Provalo

Allargato:

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

Dato 'stars', .ords.sort.squish Z-0..*sarebbe tornato(97,113,113,113)

— Brad Gilbert b2gills
fonte
6

JavaScript (Node.js) , 51 byte

Il caso della stringa di input non ha importanza.

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

Provalo online!

Come?

Per prima cosa convertiamo la stringa di input in una maschera di bit di lettere incontrate con:

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

Lo spostamento bit a bit viene elaborato con un modulo 32 implicito.

Esempio:

"feedback" --> 100001111110
               kjihgfedcba-

Quindi 'riduciamo' le esecuzioni di 1 consecutivi nella maschera di bit ripetutamente E 'con una copia spostata a sinistra di se stesso fino a quando tutti i bit vengono cancellati:

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

Il numero di lettere consecutive in ordine alfabetico è il numero di iterazioni del processo sopra descritto. Da qui la funzione ricorsiva:

g = _ => s && 1 + g(s &= s * 2)
— Arnauld
fonte
5

Pyth , 9 byte

le}#G.:S{

Si presume che l'input sia una stringa in minuscolo. Provalo online qui o verifica tutti i casi di test contemporaneamente qui .

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
fonte
Ottimo metodo usando il fatto che le sottostringhe sono ordinate per lunghezza!
— Jonathan Allan,
Sarà molto meno efficiente, ma puoi usarlo yal posto di .:.
— FryAmTheEggman,
5

MATL , 10 byte

2Y2imY'*X>

L'ingresso è in minuscolo.

Provalo online! Oppure verifica tutti i casi di test .

Questo utilizza un mix di approcci di @ Sundar (vecchio) e @ ngn .

Spiegazione

Considera l'input 'tutorial'come esempio.

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
— Luis Mendo
fonte
5

05AB1E , 6 byte

Œ...é→æ

êæAÃθg

Provalo online!

Anche 6 byte

Salvato 2 byte, sempre grazie ad Adnan : usando ASåinvece êÇ¥Θ, eliminando così anche la necessità di incrementare il massimo alla fine. Vedi la cronologia delle revisioni per confrontare i beviour dei due metodi.

ASåγOà

Provalo online!

Come funzionano

Mi piacciono le sfide come questa che portano a una varietà di approcci diversi. 

êæ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.
— Mr. Xcoder
fonte
Il primo programma può essere giocato a golf êæAÃ`ge il secondo programma può essere giocato a golf ASåγOZ.
— Adnan,
@Adnan Grazie, aggiornato! Mi piace il ASåtrucco.
— Mr. Xcoder,
4

TSQL (Microsoft SQL Server), 206 byte

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

Per l'input, utilizzare la seguente DECLAREistruzione prima del codice:

DECLARE @ varchar(200) = 'propinquities';

Si prevede che l'input sia nello stesso caso (maiuscole o minuscole non contano, ma maiuscole e minuscole non funzionerebbero).

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

Spiegazione:

Divide la stringa in una riga per ogni carattere (adattato da /programming//a/27623321/1474939 ) nelCTE cte.

Quindi, trova esecuzioni di lettere consecutive convertendole nel codice ASCII in Runs cte.

Infine, seleziona la corsa più grande e riporta nuovamente nell'istruzione select.

— Brian J
fonte
Buona risposta, ottimo uso del CTE. Non sono sicuro che ciò possa aiutare o danneggiare il numero di byte, ma il metodo "approvato" per ottenere l'input in T-SQL è tramite una tabella pre-creata .
— BradC,
@BradC Se posso prendere una tabella con ogni riga come un carattere (un po 'come un array di caratteri invece di una stringa), aiuterebbe a rimuovere un CTE. Se deve essere ancora una riga, probabilmente è quasi uguale a prenderlo come variabile di input. Grazie per l'idea però!
— Brian J,
4

C (gcc) , 58 56 byte

Salvato 2 byte grazie a @gastropner

Utilizza lo stesso approccio la mia risposta Node.js . Il caso della stringa di input non ha importanza.

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

Provalo online!

Commentate

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
fonte
È l'implementazione specifica che 1<<*savvolge o è un comportamento standard?
— Jonathan Frech,
@JonathanFrech Penso che sia un comportamento ufficialmente indefinito. Quindi deve essere specifico per l'implementazione.
— Arnauld
Perché abbastanza interessante sembra avvolgere solo quando viene calcolato in fase di esecuzione. Al momento della compilazione 1<<32genera 0ed emette un avviso sulla dimensione del tipo di dati.
— Jonathan Frech
In realtà, dubito che il compilatore applichi esplicitamente una maschera a 5 bit. È probabile che ciò avvenga a livello di CPU.
— Arnauld,
2
@Arnauld lo è (vedere la nota: "[...] L'operando di conteggio può essere un valore immediato o registrare CL. Il conteggio è mascherato su 5 bit, il che limita l'intervallo di conteggio da 0 a 31.")
— ErikF
3

C (gcc) , 100 byte

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

Provalo online!

Spiegazione

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

Provalo online!

— Jonathan Frech
fonte
+1 per "c, o, u; n (t, e, r)" :)
3

MATL , 12 10 byte

91:wX-dX>q

Provalo online!

Spiegazione:

91:- Crea l'elenco di numeri da 1 a 91. 91 è il carattere '[', che viene dopo 'Z'. Quindi questo crea efficacemente l'elenco di tutti i caratteri da '\ x1' a '['. (Vogliamo principalmente quelli nell'intervallo ['A'-1:' Z '+ 1], ma avere il resto non fa male e ha bisogno di meno bytunt.)

w - Input implicito, porta l'input in cima allo stack (supponi "TUTORIAL")

X- - Imposta la differenza. Questo lascia solo i caratteri che non sono stati trovati nella stringa di input, nel loro ordine originale ('stable'). Pila:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Differenza tra elementi successivi in ​​tale elenco. Pila:[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> - Ottieni il massimo di tali differenze, ovvero il numero massimo di alfabeti consecutivi mancanti dalla differenza impostata.

q - Decrementa per ottenere il conteggio effettivo dei personaggi

Più vecchio:

12 byte

Sud1=Y'*X>sQ

Provalo online!

— Sundar - Ripristina Monica
fonte
Tanti approcci :-)
— Luis Mendo,
3

K (ngn / k) , 17 15 byte

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

Provalo online!

- c'è solo per convertire i caratteri in numeri (non importa se sono negativi)

{ }\ applica una funzione fino alla convergenza, preservando risultati intermedi

x+1 aggiungi 1 a ciascun numero in x

^ "senza": l'elenco a sinistra senza elementi presenti nell'elenco a destra

x^x^x+1significa xintersecato conx+1

1_ rilascia il primo elemento

# contare

— NGN
fonte
#1_{x^x^x+1}\-?
— Adám,
@Adám sì, un giorno dovrei far funzionare i treni ...
— ngn,
concettualizzarlo come l'intersezione con l'incremento fino a quando la convergenza non è piuttosto piacevole
— Giona
i treni funzionano
— ngn
2

Retina 0.8.2 , 54 byte

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

Provalo online! Il link include casi di test. Spiegazione:

O`.

Ordina le lettere in ordine.

D`.

Deduplica le lettere.

.
$&$&¶

Duplica ogni lettera su righe separate.

T`l`_l`¶.

Decrementa il primo di ogni coppia.

(.)¶\1
$1

Se ora corrisponde al personaggio precedente, uniscili nuovamente.

.(.+)
$.1

Conta le lunghezze di tutte le piste.

O#^`

Ordinarli in ordine numerico inverso.

1G`

Prendi il primo (il più grande).

— Neil
fonte
2

J, 16 byte

-7 byte grazie a FrownyFrog

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

Provalo online!

spiegazione

[: >./ 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
— Giona
fonte
Penso che tu possa usare al ]posto di ~.@/:~L'alfabeto è già ordinato, quindi non è necessario ordinare l'input e conservare solo gli elementi unici. TIO - 18 byte
— Galen Ivanov,
1
16
— FrownyFrog,
@FrownyFrog e Galen, grazie ad entrambi! Col senno di poi avrebbe dovuto essere ovvio che prima non avevo bisogno di uniq / sort.
— Giona,
2

C (gcc) , 98 92 byte

Grazie a Jonathan Frech per i suggerimenti.

Maiuscole-only.

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

Provalo online!

— ErikF
fonte
In realtà non è necessario il k;alla fine. Il ritorno implicito di gcc è un effetto collaterale dell'assegnazione di variabili che apparentemente viene eseguita come ultimo passo nel ciclo for.
— Jonathan Frech,
Possibili 95 byte .
— Jonathan Frech,
@JonathanFrech Non mi fido dei ritorni impliciti di gcc. Non sempre accadono come mi aspetto, e spesso non funzionano affatto per puntatori e virgola mobile. Fortunatamente, al di fuori del codice golf non li uso mai! :-)
— ErikF,
2

Japt -h , 9 byte

Maiuscole e minuscole, accetta input come una stringa o una matrice di caratteri.

;CôkU mÊn

Provalo o esegui più test (la seconda riga serve come sostituto del -hflag in modo che il flag possa essere utilizzato per elaborare più input)

Spiegazione

              :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
— ispido
fonte
@Downvoter, potresti fornire un motivo per il tuo -1, per favore?
— Shaggy,
2

Perl 5, 68 byte

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

Provalo online .

Ungolfed:

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);
— Denis Ibaev
fonte
2

C (cc) , 66 65 63 byte

Presuppone che l'input contenga solo lettere minuscole. Innanzitutto, passa sopra la stringa e imposta i bit in un numero intero in base al quale vengono visualizzate le lettere. Successivamente, conta la sequenza più lunga di 1 bit nell'intero.

Modifica: aè globale, quindi verrà inizializzato a 0 alla prima chiamata. Il secondo loop si assicura che sia reimpostato su 0 prima di tornare. Pertanto, possiamo evitare di ripristinarlo manualmente.

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

Provalo online!

— gastropner
fonte
2

Perl 5, 62 + 2 (-nF flag) = 64 byte

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

Provalo online .

Perl 5, 68 byte

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

Provalo online .

— Denis Ibaev
fonte
1
Bel approccio! Non avevo preso in considerazione questo metodo ... Puoi salvare qualche byte usando -pFe -MList::Util+(max)per arrivare a 56: provalo online!
— Dom Hastings,
@DomHastings -MList::Util=maxaggiunge 16 byte al punteggio del risultato.
— Denis Ibaev,
Se capisco correttamente il nuovo punteggio, i flag della riga di comando non vengono conteggiati come byte, ma come una lingua con punteggio separato, quindi piuttosto che solo Perl, sarebbe Perl -MList::Util+(max) -pFo simile. codegolf.meta.stackexchange.com/a/14339/9365
— Dom Hastings
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 );
— balestruccio
fonte
2

Brachylog , 14 13 12 byte

{⊇pS∧ẠsSl}ᶠ⌉

Provalo 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

Abbastanza lento da non finire per l'input "antidisestablishmentarianism" su TIO. Uno relativamente più veloce per +1 byte:

13 byte

{dosS∧ẠsSl}ᶠ⌉

Provalo online!

Usa al dosposto di ⊇p: S è un dubstring s orted sedificato dell'input, invece che solo una permutazione di alcuni sottoinsiemi.

— Sundar - Ripristina Monica
fonte
1

Haskell , 87 byte

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

Provalo online!

Si aspetta caratteri minuscoli

Spiegazione:

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
fonte
1

Pyth - 11 byte

le@.:G).:S{

L'input deve essere racchiuso tra virgolette. Se non consentito:

Pyth - 12 byte

le@.:G).:S{z

Spiegazione:

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
fonte
1

Java 8, 77 byte

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 risposta C di Port of Arnauld . Provalo online qui .

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
fonte
1

> <> , 63 byte

Legge caratteri minuscoli da stdin, invia un numero a stdout. 

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

Provalo 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
— Sasha
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.