Ihre Herausforderung: Schreiben Sie eine Funktion, die eine Zeichenfolge s, ein Zeichen cund die Länge des längsten Laufs von cin nimmt s. Die Länge des Laufs wird sein l.

Regeln :

• Wenn die sLänge 0 ist oder cleer ist, lsollte 0 sein.
• Wenn es keine Instanzen von cin gibt s, lsollte 0 sein.
• Es gelten Standard- Regelungslücken und Standard-E / A-Regeln .
• Egal wo sich im sLauf von cs befindet, lsollte gleich sein.
• Beliebige druckbare ASCII-Zeichen können in sund erscheinen c.

Testfälle :

s,c --> l
"Hello, World!",'l'  -->  2
"Foobar",'o'         -->  2
"abcdef",'e'         -->  1
"three   spaces",' ' -->  3
"xxx xxxx xx",'x'    -->  4
"xxxx xx xxx",'x'    -->  4
"",'a'               -->  0
"anything",''        -->  0

Gewinner :

Wie beim Code-Golf gewinnt die kürzeste Antwort in jeder Sprache.

05AB1E , 5 Bytes

Code:

SQγOM

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung:

SQ      # Check for each character if it is equal to the second input
  γ     # Split the list of zeros and ones into groups
   O    # Sum each array in the arrays
    M   # Get the maximum

Mathematica, 35 Bytes

Max[Tr/@Split@Boole@Thread[#==#2]]&

Reine Funktion, die eine Liste von Zeichen und ein anderes Zeichen als Eingabe verwendet und eine nicht negative Ganzzahl zurückgibt. Verbesserte meine erste Anstrengung, indem ich Adnans Beobachtung verwendete (stimmt zu!), Dass man testen sollte, ob das Sonderzeichen gleich ist, bevor man das Array aufteilt.

Thread[#==#2]prüft, ob jedes eingegebene Zeichen im ersten Argument dem als zweites Argument angegebenen Zeichen entspricht. Boolekonvertiert das resultierende Trues und Falses in 1s und 0s. Splitteilt die Liste in Läufe von aufeinanderfolgenden Elementen auf; Tr/@summiert jede Unterliste und Maxfindet den Gewinner. (Aufgrund der MaxFunktionsweise gibt diese Funktion zurück, wenn das erste Argument die leere Liste ist -∞. Sie wissen also, tun Sie das nicht.)

erste Einreichung (51 Bytes)

Max[Split@#/.a:{c_String..}:>Boole[c==#2]Length@a]&

Split@#teilt die Eingabe in Läufe aufeinanderfolgender Zeichen auf, z. B. {{"t"}, {"h"}, {"r"}, {"e", "e"}, {" ", " ", " "}, {"s"}, {"p"}, {"a"}, {"c"}, {"e"}, {"s"}}für den vierten Testfall. /.a:{c_String..}:>ersetzt jeden Teilausdruck a, der eine Liste eines wiederholtes Zeichen cdurch Length@amultipliziert Boole[c==#2], das ist , 1wenn cdas Eingabezeichen und entspricht 0ansonsten. Dann Maxextrahiert die Antwort.

Japt , 20 18 15 Bytes

fV+Vî+)ª0)n o l

Probieren Sie es online!

5 Bytes gespart dank obarakon und ETHproductions

Python , 38 Bytes

f=lambda s,c:+(c in s)and-~f(s,c+c[0])

Probieren Sie es online!

Dennis hat 3 Bytes gespart, indem cer eine Zeichenfolge mit doppelten Zeichen aktualisiert hat , anstatt rekursiv eine Zahl zu aktualisieren, mit der multipliziert cwerden soll.

05AB1E , 11 6 Bytes

-5 Bytes dank Carusocomputing

γvy²¢M

Probieren Sie es online!

γ      # split into chunks of consecutive equal elements
 vy    # For each chunk...
   ²¢  #  Count the number of input characters in this chunk
     M #  Push the largest count so far

Haskell, 43 39 Bytes

f c=maximum.scanl(\n k->sum[n+1|c==k])0

Probieren Sie es online!

Führen Sie den String durch und ersetzen Sie das aktuelle Zeichen durch einen Zähler, der erhöht wird, wenn er gleich ist, coder setzen Sie ihn auf zurück, 0wenn nicht. Nimm das Maximum der Liste.

Danke an @xnor für 4 Bytes.

C # 116 115 Bytes

Mein erster Code Golf

Wurde bearbeitet, weil die ursprüngliche Übermittlung ein Snippet war und der erforderliche Namespace für reguläre Ausdrücke fehlte

Bearbeiten Sie die vollständige Umschreibung von Nummer 2, um Zeichen mit speziellen Bedeutungen für reguläre Ausdrücke zu unterstützen

using System.Linq; s => c => System.Text.RegularExpressions.Regex.Replace (s, "[^" + c + "]", ++ c + ""). Split (c) .Max (x => x.Länge);

using System.Linq;s=>c=>{var r=(char)(c-1);return string.Join("",s.Select(x=>x==c?c:r)).Split(r).Max(x=>x.Length)};

JavaScript (ES6), 54 53 51 Byte

-2 Byte dank @Neil
-1 Byte dank @apsillers

s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j

Nimmt die Eingabe in currying Syntax: f("foobar")("o").

Testschnipsel

f=
s=>c=>[...s].map(x=>j=(i=x==c&&i+1)>j?i:j,i=j=0)&&j

String: <input id=I> Letter: <input id=J maxlength=1 size=1> <button onclick='O.innerHTML+=`f("${I.value}")("${J.value}") = ${f(I.value)(J.value)}\n`'>Run</button><pre id="O"></pre>

Eine weitere Option mit evalund for(54 Bytes)

s=>c=>eval("i=j=0;for(x of s)i=x==c&&i+1,i>j?j=i:0;j")

Alte Antwort mit Regex (85 Bytes)

s=>c=>c?Math.max(...s.match(eval(`/${/\w/.test(c)?c:"\\"+c}*/g`)).map(x=>x.length)):0

JavaScript (Firefox 30-57), 75 bis 72 Byte

(s,c)=>Math.max(0,...(for(s of s.split(/((.)\2*)/))if(s[0]==c)s.length))

ES6-kompatibles Snippet:

f=
(s,c)=>Math.max(0,...s.split(/((.)\2*)/).filter(s=>s[0]==c).map(s=>s.length))

<div oninput=o.textContent=f(s.value,c.value)><input id=s><input id=c maxlength=1 size=1><pre id=o>0

split Gibt eine Reihe leerer Zeichenfolgen und einzelner Zeichen sowie die Abläufe zurück, dies hat jedoch keine Auswirkungen auf das Ergebnis.

Mikro 112 Bytes

{T l m 1+:Q # T Q T l~:r}:Z{T[0]+}:X
{i s m:n
n p = if(Z,X)
i L=if(,a)}:a
0\\:C:s:i"":p"":n[0]:T
s l:L
a
T l m:\

C (gcc) 63 Bytes

i;m;f(s,c)char*s;{for(i=m=0;*s;s++)*s^c?m=m>i?m:i,i=0:i++;s=m;}

Probieren Sie es online!

Perl 6 ,  45 43  42 Bytes

->$_,$c {$c&&$_??.comb(/$c+/)».chars.max!!0}

Probier es aus

->$_,$c {$c&&$_??.comb(/$c+/).max.chars!!0}

Probier es aus

->$_,$c {$c&$_??.comb(/$c+/).max.chars!!0}

Probier es aus

Erweitert:

-> $_, $c {       # pointy block lambda

    $c & $_       # AND junction of $c and $_
                  #   empty $c would run forever
                  #   empty $_ would return 4 ( "-Inf".chars )

  ??              # if True (neither are empty)

    .comb(/$c+/)  # find all the substrings
    .max          # find the max
    .chars        # get the length

  !!              # if False (either is empty)

    0             # return 0
}

JavaScript, ES6, 52

Rekursive Lösung, bei der die Zeichenfolge als Array behandelt wird (Hinweis: Die ursprüngliche Eingabe ist immer noch eine Zeichenfolge) und Zeichen von links nach rechts verwendet werden C:

f=([C,...s],c,t=0,T=0)=>C?f(s,c,C==c&&++t,t>T?t:T):T

Zeichnet den aktuellen Einlauf tund den globalen Best-In aufT .

Erläuterung:

f=            // function is stored in `f` (for recursion)
  ([C,...s],  // turn input string in first-char `C` and the rest in `s`
   c,         // argument `c` to search for
   t=0,T=0)   // current total `t`, best total `T`
     =>
        C?             // if there is still any char left in the string
          f(s,c,       // recursively call `f`
            C==c&&++t, // increment `t` if char is match, or set `t` to `false`
            t>T?t:T)   // set global `T` to max of `t` and `T`
          :T           // when string is depleted, return `T`

Das Setzen tvon falseauf Nicht-Übereinstimmungen funktioniert, weil jedes Mal, wenn tes erhöht wird, falseso behandelt wird 0(dh so false + 1ist 1) und falseniemals mehr als ein Wert in global-max verglichen wird T.

Gelee , 5 Bytes

=ŒgṀS

Dies ist eine dyadische Verknüpfung / Funktion, die eine Zeichenfolge und ein Zeichen akzeptiert. Beachten Sie, dass es nicht als vollständiges Programm funktionieren kann, da für die Eingabe über Befehlszeilenargumente die Python-Syntax verwendet wird und Python im Gegensatz zu Jelly Singleton-Zeichenfolgen nicht von Zeichen unterscheidet.

Probieren Sie es online!

Wie es funktioniert

=ŒgṀS  Main link. Left argument: s (string). Right argument: c (character)

=      Compare all characters in s with c, yielding 1 for c and 0 otherwise.
 Œg    Group adjacent, equal Booleans in the resulting array.
   Ṁ   Take the maximum. Note that any array of 1's will be greater than any array
       of 0's, while two arrays of the same Booleans are compared by length.
    S  Take the sum, yielding the length for an array of 1's and 0 otherwise.

Retina , 25 Bytes

(.).*?(\1*)(?!.+\2).*
$.2

Probieren Sie es online!

Das erste Zeichen ist das zu prüfende Zeichen.

APL (Dyalog) , 18 11 Bytes

Erfordert das Austauschen ⊂mit ⊆in Version 16.0 oder mit ⎕ML←3(Standard auf vielen Systemen).

⌈/0,≢¨⊂⍨⎕=⎕

Probieren Sie es online!

⎕=⎕ Boolescher Wert für die Gleichheit zwischen zwei Eingaben

⊂⍨ Selbstpartitionierung (Partitionen beginnen, bei denen ein Element ungleich Null größer als sein Vorgänger ist)

≢¨ zählen jeden

0, voranstellen einer Null (für die Fälle mit leerer Eingabe)

⌈/ davon max

Alte Lösung

Fordert zuerst zur Eingabe von s auf , dann zur Eingabe von c

⌈/0,(⎕,¨'+')⎕S 1⊢⎕

Probieren Sie es online!

⎕ Eingabeaufforderung für s

⊢ dafür

(... )⎕S 1PCRE S uche für die Längen der Vorkommen

 '+' ein Pluszeichen (bedeutet eines oder mehrere)

 ,¨  an jedes der Elemente von angehängt

 ⎕ der Aufgeforderte c

0, voranstellen einer Null (für die Fälle mit leerer Eingabe)

⌈/ davon max

c muss als 1-Element-Vektor einer eingeschlossenen Zeichenfolge angegeben werden, wenn ein Escape-Vorgang erforderlich ist.

PHP, 70 67 Bytes

drei Versionen:

while(~$c=$argv[1][$i++])$x=max($x,$n=($c==$argv[2])*++$n);echo+$x;
while(~$c=$argv[1][$i++])$x=max($x,$n=$c==$argv[2]?++$n:0);echo+$x;
for(;++$n&&~$c=$argv[1][$i++];)$x=max($x,$n*=$c==$argv[2]);echo+$x;

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Laufen Sie mit ihnen-r oder testen Sie sie online .

PHP , 70 Bytes

for(;~$c=$argv[1][$i++];)$r[]=$argv[2]==$c?++$n:$n=0;echo$r?max($r):0;

Probieren Sie es online!

PHP , 75 Bytes

for(;~$s=substr($argv[1],$i++);)$r[]=strspn($s,$argv[2]);echo max($r?:[0]);

Probieren Sie es online!

PHP , 83 Bytes

<?=@preg_match_all("<".preg_quote($argv[2])."+>",$argv[1],$t)?strlen(max($t[0])):0;

Probieren Sie es online!

+8 Bytes zu vermeiden @

<?=($a=$argv[2])&&preg_match_all("<".preg_quote($a)."+>",$argv[1],$t)?strlen(max($t[0])):0;

JavaScript (ES6), 47 40 38 Bytes

(7 Bytes dank @Neil und 2 Bytes dank @HermanLauenstein gespeichert.)

s=>g=c=>c&&s.includes(c)?1+g(c+c[0]):0

Erläuterung:

Sucht rekursiv nach einer längeren Ausführung, bis keine gefunden wird.

Snippet:

let f=

s=>g=c=>c&&s.includes(c)?1+g(c+c[0]):0

console.log(f('Hello, World!')('l'  ));  //2
console.log(f('Foobar')('o'         ));  //2
console.log(f('abcdef')('e'         ));  //1
console.log(f('three   spaces')(' ' ));  //3
console.log(f('xxx xxxx xx')('x'    ));  //4
console.log(f('xxxx xx xxx')('x'    ));  //4
console.log(f('')('a'               ));  //0
console.log(f('anything')(''        ));  //0

Gelee, 10 9 Bytes

f⁴L
ŒgÇ€Ṁ

Erläuterung:

f⁴L
f⁴      -Filter by the character argument.
  L     -Return Length of filtered String.

ŒgÇ€»/
Œg      -Group string by runs of characters.
  ǀ    -Run above function on each group.
    Ṁ   -Return the largest in the list.

Probieren Sie es online!

Python 3 , 71 Bytes

f=lambda s,c,m=0,k=0:s and f(s[1:],c,-~m*(s[0]==c),max(m,k))or max(m,k)

Probieren Sie es online!

Haskell , 66 Bytes

import Data.List
((maximum.(0:).map length).).(.group).filter.elem

Probieren Sie es online!

Eine etwas leichter zu lesende Version - nicht sinnlos:

f c s = maximum (0:(map length (filter (elem c) (group s))))

Gruppiert die Zeichenfolge nach Buchstaben, filtert nach den Gruppen, die das richtige Zeichen enthalten, findet dann die Längen, fügt 0 an die Längenliste an, falls sie nicht angezeigt wird, und ermittelt schließlich den Maximalwert.

Mathematica, 109 Bytes

(s=Differences[First/@StringPosition[#,#2]];k=t=0;Table[If[s[[i]]==1,t++;If[k<t,k=t],t=0],{i,Length@s}];k+1)&

Eingang

["xxx xxxx xx", "x"]

Python 2 , 69 Bytes

lambda s,c:c and max(map(len,re.findall(c+'+',s))or[0])or 0
import re

Probieren Sie es online!

CJam , 20 19 18 16 Bytes

0q~e`f{~@=*}$+W=

Probieren Sie es online!

Erläuterung

0                 e# Push 0. We'll need it later.
 q~               e# Read and eval input. Pushes c and s to the stack.
   e`             e# Run-length encode s: turns it into an array of [length, char] pairs.
     f{           e# Map over these pairs using c an extra parameter:
       ~          e#  Dump the pair to the stack.
        @=        e#  Bring c to the top, check equality with the char, pushing 0 or 1.
          *       e#  Multiply the length by the result.
           }      e# (end map)
            $     e# Sort the resulting list in ascending order.
             +    e# Prepend the 0 from before, in case it's empty.
              W=  e# Get the last element.

Excel, 56 Bytes

{=MAX(IFERROR(FIND(REPT(A2,ROW(A:A)),A1)^0*ROW(A:A),0))}

ssollte eingegeben werden A1.
csollte eingegeben werden A2.
Die Formel muss eine Matrixformel ( Ctrl+ Shift+ Enter) sein, die geschweifte Klammern hinzufügt{ } .

Technisch ist dies nur möglich, wenn die längste Ausführung weniger als 1.048.576 beträgt (was 2 ^ 20 entspricht), da Sie auf diese Weise in der aktuellen Excel-Version Zeilen in einem Arbeitsblatt haben. Da die Millionen + -Werte bei jeder Neuberechnung in den Speicher geladen werden, ist dies keine schnelle Formel.

MATL , 15 Bytes

0i0v=dfd1L)0hX>

Probieren Sie es online!

Der grundlegende Algorithmus ist sehr einfach (keine Verwendung von Split!), Aber ich musste einwerfen 0i0vund 0hdie Kantenfälle berücksichtigen. Trotzdem fand ich den Ansatz gut, und vielleicht kann ich noch eine andere Technik finden, um die Randfälle zu behandeln: Der Algorithmus findet die längste Ausführung in der Mitte einer Zeichenfolge in Ordnung, aber nicht für einzelne Zeichen oder leere Zeichenfolgen; Ich teste immer noch, ob ich die Variablen an besseren Stellen auffüllen kann, um bessere Ergebnisse zu erzielen.

0i0v % Prepends and appends a zero to the (implicit) input.
   = % Element-wise equality with the desired char (implicit input)
   d % Pairwise difference. Results in a 1 at the start of a run, and -1 at the end.
   f % Get indices of 1's and -1's.
   d % Difference to get length of the runs (as well as length of non-runs)
 1L) % Only select runs, throw out non-runs. We now have an array of all run lengths.
  0h % 'Find' (`f`) returns empty if no run is found, so append a zero to the previous array.
  X> % Maximum value.

Funktioniert nicht leer c. Andererseits nehme ich an, dass jede Zeichenfolge eine unendliche Anzahl leerer Zeichenfolgen zwischen den einzelnen Zeichen enthält :)

R , 66 58 Bytes

-8 Bytes dank BLT und MickyT

function(s,c)max((r=rle(el(strsplit(s,''))))$l*(r$v==c),0)

Gibt eine anonyme Funktion zurück. TIO hat einen 1-Byte-Unterschied, weilel es aus unerklärlichen Gründen nicht funktioniert.

Probieren Sie es online!

Java 8, 67 65 Bytes

s->c->{int t=0,m=0;for(char x:s)m=m>(t=x==c?t+1:0)?m:t;return m;}

-2 Bytes dank @ OlivierGrégoire

Nimmt Eingaben sals char[], und calschar

Erläuterung:

Probieren Sie es hier aus.

s->c->{          // Method with char[] and char parameters and int return-type
  int t=0,       //  Temp counter-integer
      m=0;       //  Max integer
  for(char a:s)  //  Loop over the characters of the input
    m=m>(
     t=x==c?     //   If the current character equals the input-character:
      t+1        //    Raise `t` by 1
      :          //   Else:
       0)        //    Reset `t` to 0
    ?m:t;        //   If `t` is now larger than `m`, put `t` as new max into `m`
                 //  End of loop (implicit / single-line body)
  return m;      //  Return the resulting max
}                // End of method

Ruby, 40 Bytes

->s,c{s.split(%r{[^#{c}]}).max&.size||0}

Probieren Sie es online!