Aufeinanderfolgende Zeichen zählen

24

Bei einer Zeichenfolge, die nur Buchstaben enthält, wird die Länge der längsten Folge aufeinanderfolgender alphabetischer Buchstaben ausgegeben, die das Wort enthält, wobei die Reihenfolge keine Rolle spielt. Ein beispielhafter Algorithmus kann das Wort sortieren, Duplikate entfernen und dann die Länge des längsten Laufs ausgeben.

Testfälle

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

Zum Beispiel antidisestablishmentarianismenthält die Buchstaben abdehilmnstr. Die längsten Abfahrten sind lmnund rst, beide Länge 3.

Anmerkungen

Sie können alle Kleinbuchstaben, Großbuchstaben oder gemischten Buchstaben als Eingabe verwenden, die Groß- und Kleinschreibung kann jedoch keine Informationen über das Wort codieren (dh Sie können die ersten nZeichen nicht in Großbuchstaben schreiben, wenn ndie Länge der längsten Ausführung erreicht ist).

Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.

code-golf  string  alphabet 
— Stephen
quelle
@H.PWiz, ich vermute, das ist ein Tippfehler, und das sollte auch so sein rst: Eindeutig machen, sortieren und den längsten Durchlauf in Folge erzielen. Können wir Eingaben als Array von Zeichen annehmen?
— Shaggy
@ Shaggy ja, definitiv, ich habe es nicht aufgenommen, weil ich dachte, es sei ein Standard
— Stephen
Ist 'a' neben 'z' - sollte 'zebra' 2 oder 3 Punkte erzielen?
— Jonathan Allan
(... nach Ihrem Beispielalgorithmus zu urteilen, schätze ich "nein" und "2")
— Jonathan Allan
@ JonathanAllan Sie sind richtig
— Stephen

Antworten:

10

Jelly ,  10 9 8 7  6 Bytes

OṬṣ0ZL

Probieren Sie es online!

9 benutzte Soks Methode :ṢQẆẇƇØaṪL

Wie?

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
quelle
7

APL (Dyalog Classic) , 10 9 Bytes

-1 Byte dank H.PWiz

≢⍉↑⊆⍨⎕a∊⍞

Probieren Sie es online!

⍞ gibt einen String ein

⎕a ist das englische Alphabet in Großbuchstaben

⎕a∊⍞ ein boolescher Vektor der Länge 26 - welche Buchstaben kommen in der Zeichenfolge vor?

⊆⍨ bilden Vektoren aufeinanderfolgender Einsen

≢⍉↑ mischen Sie es in eine Matrix, transponieren Sie es und geben Sie seine Höhe zurück. Ermitteln Sie effektiv die Länge des längsten Vektors von 1s

— ngn
quelle
1
⌈/≢¨->≢⍉↑
— H.PWiz
7

R , 44 43 Bytes

Funktioniert mit einem Array von Kleinbuchstaben. Bearbeiten: Es wurde vom Testen der wahren Werte zum Multiplizieren mit der T / F für ein Byte geändert.

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

Probieren Sie es online!

Führt eine Lauflängencodierung für Buchstaben aus, die in den angegebenen Zeichen enthalten sind, und gibt dann den Maximalwert für die Wahrheiten zurück.

— MickyT
quelle
Ich habe mit utf8ToInt an einer ähnlichen RLE-Lösung gearbeitet, aber es ist viel schlauer, eine Reihe von Zeichenfolgen zu verwenden. +1
— JayCe
@JayCe Begann auf die gleiche Weise, stellte dann aber fest, dass ein% in%
— -Scheck
6

Perl 6 , 41 Bytes

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

Probier es aus

Erweitert:

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

Gegeben 'stars', .ords.sort.squish Z-0..*würde wiederkommen(97,113,113,113)

— Brad Gilbert b2gills
quelle
6

JavaScript (Node.js) , 51 Byte

Der Fall der Eingabezeichenfolge spielt keine Rolle.

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

Probieren Sie es online!

Wie?

Wir konvertieren zuerst die Eingabezeichenfolge in eine Bitmaske der gefundenen Buchstaben mit:

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

Die bitweise Verschiebung wird mit einem impliziten Modulo 32 verarbeitet.

Beispiel:

"feedback" --> 100001111110
               kjihgfedcba-

Dann 'reduzieren' wir die Anzahl aufeinanderfolgender Einsen in der Bitmaske, indem wir sie wiederholt mit einer nach links verschobenen Kopie von sich ANDEN, bis alle Bits gelöscht sind:

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

Die Anzahl aufeinanderfolgender Buchstaben in alphabetischer Reihenfolge ist die Anzahl der Iterationen des obigen Prozesses. Daher die rekursive Funktion:

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

Pyth , 9 Bytes

le}#G.:S{

Die Eingabe wird als Zeichenfolge in Kleinbuchstaben angenommen. Versuchen Sie es online aus hier , oder überprüfen alle Testfälle auf einmal hier .

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
quelle
Tolle Methode, um die Teilzeichenfolgen nach Länge zu sortieren!
— Jonathan Allan
Es wird viel weniger effizient sein, aber Sie können yanstelle von verwenden .:.
— FryAmTheEggman
5

MATL , 10 Bytes

2Y2imY'*X>

Die Eingabe erfolgt in Kleinbuchstaben.

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Dieser verwendet eine Mischung aus @ Sundars (alt) und @ NGN Ansätze.

Erläuterung

Betrachten Sie die Eingabe 'tutorial'als Beispiel.

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
quelle
5

05AB1E , 6 Bytes

Dank Adnan 1 Byte gespart : Nehmen Sie die zusammenhängenden Teilzeichenfolgen und sortieren Sie sie nach Länge ( Œ...é) stattdessen das integrierte Powerset ( ) zu verwenden.→æ

êæAÃθg

Probieren Sie es online!

Auch 6 Bytes

2 Bytes gespart, wieder dank Adnan : ASåstattdessen verwenden êÇ¥Θ, wodurch auch die Notwendigkeit entfällt, das Maximum am Ende zu erhöhen. Siehe die Revisionshistorie , um die beviours der beiden Methoden zu vergleichen.

ASåγOà

Probieren Sie es online!

Wie das funktioniert

Ich mag Herausforderungen wie diese, die zu einer Vielzahl unterschiedlicher Ansätze führen. 

êæ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
quelle
Das erste Programm kann mit Golf gespielt werden êæAÃ`gund das zweite Programm kann mit Golf gespielt werden ASåγOZ.
— Adnan
@Adnan Danke, aktualisiert! Ich mag den ASåTrick.
— 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

Verwenden Sie zur Eingabe die folgende DECLAREAnweisung vor dem Code:

DECLARE @ varchar(200) = 'propinquities';

Es wird erwartet, dass die Eingabe in Groß- und Kleinschreibung erfolgt (Groß- und Kleinschreibung spielt keine Rolle, gemischte Groß- und Kleinschreibung würde jedoch nicht funktionieren).

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

Erläuterung:

Unterteilt die Zeichenfolge in eine Zeile für jedes Zeichen (angepasst von /programming//a/27623321/1474939 ) in der CTECTE.

Findet dann Läufe aufeinanderfolgender Buchstaben durch Konvertieren in den ASCII-Code in der RunsCTE.

Zuletzt wird der größte Lauf ausgewählt und in der select-Anweisung zurückgemeldet.

— Brian J
quelle
Gute Antwort, sehr gute Nutzung des CTE. Wir sind uns nicht sicher, ob dies zu einer Beeinträchtigung Ihrer Byteanzahl führen würde, aber die "genehmigte" Methode zum Abrufen von Eingaben in T-SQL erfolgt über eine vorab erstellte Tabelle .
— BradC
@BradC Wenn ich eine Tabelle mit jeder Zeile als ein Zeichen annehmen kann (ähnlich wie ein Zeichen-Array anstelle eines Strings), dann würde es helfen, einen CTE zu entfernen. Wenn es immer noch eine Zeile sein muss, entspricht dies wahrscheinlich in etwa der Verwendung als Eingabevariable. Vielen Dank für die Idee!
— Brian J
4

C (gcc) , 58 56 Bytes

2 Bytes gespart dank @gastropner

Verwendet den gleichen Ansatz wie meine Node.js-Antwort . Der Fall der Eingabezeichenfolge spielt keine Rolle.

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

Probieren Sie es online!

Kommentiert

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
quelle
Handelt es sich um eine spezifische Implementierung, 1<<*soder handelt es sich um ein Standardverhalten?
— Jonathan Frech
@ JonathanFrech Ich denke, das ist offiziell undefiniertes Verhalten. Es muss also implementierungsspezifisch sein.
— Arnauld
Interessanterweise scheint es nur dann einen Zeilenumbruch zu geben, wenn es zur Laufzeit berechnet wird. Bei der Kompilierung 1<<32führt 0und gibt einen Datentyp Größe Warnung.
— Jonathan Frech
Eigentlich bezweifle ich, dass der Compiler explizit eine 5-Bit-Maske anwenden würde. Wahrscheinlich geschieht dies auf CPU-Ebene.
— Arnauld
2
@Arnauld es ist (siehe den Hinweis: "[...] Der Zähloperand kann ein unmittelbarer Wert oder ein Register CL sein. Die Zählung ist auf 5 Bits maskiert, was den
— Zählbereich
3

K (ngn / k) , 17 Bytes

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

Probieren Sie es online!

{ } ist eine Funktion mit Argument x

- gibt es nur, um die Zeichen in Zahlen umzuwandeln (es ist egal, ob sie negativ sind)

{ }\ Wendet eine Funktion bis zur Konvergenz an, wobei Zwischenergebnisse erhalten bleiben

x+1 Addiere 1 zu jeder Zahl in x

^ "without" - die Liste auf der linken Seite ohne Elemente, die in der Liste auf der rechten Seite vorkommen

x^x^x+1bedeutet xgekreuzt mitx+1

1_ Lassen Sie das erste Element fallen

# Anzahl

— ngn
quelle
#1_{x^x^x+1}\-?
— Adám
@ Adám Ja, eines Tages sollte ich dafür sorgen, dass Züge funktionieren ...
— ngn
Dies als Schnittpunkt mit dem Inkrement bis zur Konvergenz zu konzipieren, ist ganz nett
— Jonah,
3

C (gcc) , 100 Bytes

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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

— Jonathan Frech
quelle
+1 für die "c, o, u; n (t, e, r)" :)
3

MATL , 12 10 Bytes

91:wX-dX>q

Probieren Sie es online!

Erläuterung:

91:- Erstellen Sie die Liste der Zahlen von 1 bis 91. 91 ist das Zeichen '[', das nach 'Z' steht. Auf diese Weise wird effektiv die Liste aller Zeichen von '\ x1' bis '[' erstellt. (Wir wollen hauptsächlich solche im Bereich ['A'-1:' Z '+ 1], aber der Rest tut nicht weh und benötigt weniger Bytecount.)

w - Implizite Eingabe, bringe die Eingabe an den Anfang des Stapels (nimm 'TUTORIALS' an)

X- - Differenz einstellen. Dies lässt nur die Zeichen, die nicht in der Eingabezeichenfolge gefunden wurden, in ihrer ursprünglichen Reihenfolge ("stabil"). Stapel:' !"#$%&'()*+,-./0123456789:;<=>?@BCDEFGHJKMNPQVWXYZ['

d - Unterschied zwischen aufeinanderfolgenden Elementen in dieser Liste. Stapel:[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> - Holen Sie sich das Maximum dieser Unterschiede, dh die maximale Anzahl aufeinanderfolgender Alphabete, die in der eingestellten Differenz fehlen.

q - Dekrementieren, um die tatsächliche Zeichenanzahl zu erhalten

Älter:

12 Bytes

Sud1=Y'*X>sQ

Probieren Sie es online!

— Sundar - Setzen Sie Monica wieder ein
quelle
So viele Ansätze :-)
— Luis Mendo
2

Retina 0.8.2 , 54 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

O`.

Sortieren Sie die Buchstaben in der Reihenfolge.

D`.

Deduplizieren Sie die Buchstaben.

.
$&$&¶

Duplizieren Sie jeden Buchstaben in separaten Zeilen.

T`l`_l`¶.

Dekrementiere das erste von jedem Paar.

(.)¶\1
$1

Wenn dies jetzt mit dem vorherigen Zeichen übereinstimmt, fügen Sie sie wieder zusammen.

.(.+)
$.1

Zählen Sie die Längen aller Läufe.

O#^`

Sortieren Sie sie in umgekehrter numerischer Reihenfolge.

1G`

Nimm die erste (größte).

— Neil
quelle
2

J, 16 Bytes

-7 Bytes dank FrownyFrog

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

Probieren Sie es online!

Erläuterung

[: >./ 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
— Jona
quelle
Ich denke, dass Sie ]anstelle von verwenden können. ~.@/:~Das Alphabet ist bereits sortiert, sodass Sie die Eingabe nicht sortieren und nur die eindeutigen Elemente behalten müssen. TIO - 18 Bytes
— Galen Ivanov
1
16
— FrownyFrog
@FrownyFrog und Galen, danke euch beiden! Im Nachhinein hätte klar sein müssen, dass ich diese Sortierung nicht zuerst brauchte.
— Jonah
2

C (GCC) , 98 92 Bytes

Vielen Dank an Jonathan Frech für die Vorschläge.

Nur Großbuchstaben.

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

Probieren Sie es online!

— ErikF
quelle
Das brauchst du k;am Ende eigentlich nicht . Das implizite Zurückgeben von gcc ist ein Nebeneffekt der Variablenzuweisung, der anscheinend als letzter Schritt in Ihrer for-Schleife ausgeführt wird.
— Jonathan Frech
Mögliche 95 Bytes .
— Jonathan Frech
@JonathanFrech Ich traue den impliziten Rückgaben von gcc nicht. Sie laufen nicht immer so ab, wie ich es mir vorgestellt habe, und bei Zeigern und Gleitkommazahlen funktionieren sie oft überhaupt nicht. Glücklicherweise benutze ich sie außerhalb des Codegolfs nie! :-)
— ErikF
2

Japt -h , 9 Bytes

Case insenstive, nimmt Eingaben als String oder als Array von Zeichen entgegen.

;CôkU mÊn

Probieren Sie es aus oder führen Sie mehrere Tests durch (die zweite Zeile dient als Ersatz für das -hFlag, sodass das Flag stattdessen zur Verarbeitung mehrerer Eingaben verwendet werden kann).

Erläuterung

              :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
— Zottelig
quelle
@Downvoter, könnten Sie -1bitte einen Grund für Ihre Frage angeben ?
— Shaggy
2

Perl 5, 68 Bytes

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

Probieren Sie es online aus .

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
quelle
2

C (GCC) , 66 65 63 Bytes

Angenommen, die Eingabe enthält nur Kleinbuchstaben. Zunächst durchläuft es die Zeichenfolge und setzt Bits in einer Ganzzahl, nach der Buchstaben angezeigt werden. Als nächstes wird der längste Streifen von 1 Bit in der ganzen Zahl gezählt.

Bearbeiten: aist global, wird also beim ersten Aufruf auf 0 initialisiert. Die zweite Schleife stellt sicher, dass sie vor der Rückkehr auf 0 zurückgesetzt wird. Daher können wir ein manuelles Zurücksetzen vermeiden.

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

Probieren Sie es online!

— Gastropner
quelle
2

Perl 5, 62 + 2 ( -nFFlag) = 64 Bytes

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

Probieren Sie es online aus .

Perl 5, 68 Bytes

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

Probieren Sie es online aus .

— Denis Ibaev
quelle
1
Netter Ansatz! Ich habe diese Methode überhaupt nicht in Betracht gezogen ... Sie können mit -pFund ein paar Bytes sparen -MList::Util+(max), um zu 56 zu gelangen: Probieren Sie es online aus!
— Dom Hastings
@DomHastings -MList::Util=maxfügt der Ergebnisbewertung 16 Bytes hinzu.
— Denis Ibaev
Wenn ich die neue Bewertung richtig verstehe, werden Befehlszeilenflags nicht als Bytes gezählt, sondern als eine separat bewertete Sprache, und nicht nur als Perl, sondern als Perl mit -MList::Util+(max) -pFoder ähnlich. 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 );
— martin
quelle
2

Brachylog , 14 13 12 Bytes

{⊇pS∧ẠsSl}ᶠ⌉

Probieren Sie es 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

Langsam genug, dass die Eingabe "Antidisestablishmentarianism" auf TIO nicht beendet wird. Relativ viel schneller für +1 Byte:

13 Bytes

{dosS∧ẠsSl}ᶠ⌉

Probieren Sie es online!

Verwenden Sie dosanstelle von ⊇p: S ist eine deduplizierte oTeilzeichenfolge sder Eingabe, anstatt nur einer Permutation einer Teilmenge.

— Sundar - Setzen Sie Monica wieder ein
quelle
1

Haskell , 87 Bytes

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

Probieren Sie es online!

Erwartet Kleinbuchstaben

Erläuterung:

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

Pyth - 11 Bytes

le@.:G).:S{

Die Eingabe muss in Anführungszeichen gesetzt werden. Wenn nicht erlaubt:

Pyth - 12 Bytes

le@.:G).:S{z

Erläuterung:

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

Java 8, 77 Bytes

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

Hafen von Arnauld ‚s C Antwort . Probieren Sie es hier online aus .

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

> <> 63 Bytes

Liest Kleinbuchstaben von stdin und gibt eine Zahl an stdout aus. 

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

Probieren Sie es 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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.