Su desafío: escriba una función que tome una cadena s, un carácter cy encuentre la longitud de la ejecución más larga de cin s. La duración de la carrera será l.

reglas :

• Si ses de longitud 0 o cestá vacío, ldebe ser 0.
• Si no hay instancias de cin s, ldebe ser 0.
• Lagunas estándares y reglas estándar de E / S se aplican.
• No importa en qué lugar se encuentre sla ejecución de cs, ldebe ser lo mismo.
• Cualquier carácter ASCII imprimible puede aparecer en sy c.

Casos de prueba :

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

Ganador :

Al igual que con el código de golf, gana la respuesta más corta en cada idioma.

05AB1E , 5 bytes

Código:

SQγOM

Utiliza la codificación 05AB1E . Pruébalo en línea!

Explicación:

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]]&

Función pura que toma una lista de caracteres y otro carácter como entrada y devuelve un entero no negativo. Mejoré mi primer esfuerzo usando la observación de Adnan (¡sube el voto!) De que uno debería probar para igualar el carácter especial antes de dividir la matriz.

Thread[#==#2]comprueba si cada carácter de entrada en el primer argumento es igual al carácter dado como el segundo argumento. Booleconvierte la resultante Trues y FalseS a 1s y 0s. Splitdivide la lista en series de elementos consecutivos; Tr/@suma cada sublista, yMax encuentra el ganador. (Debido a cómo Maxfunciona, si el primer argumento es la lista vacía, entonces esta función regresa -∞. Entonces, ya sabes, no hagas eso).

primer envío (51 bytes)

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

Split@#divide la entrada en series de caracteres consecutivos, como {{"t"}, {"h"}, {"r"}, {"e", "e"}, {" ", " ", " "}, {"s"}, {"p"}, {"a"}, {"c"}, {"e"}, {"s"}}en el cuarto caso de prueba. /.a:{c_String..}:>reemplaza cada subexpresión aque es una lista de un carácter repetido cpor Length@amultiplicado por Boole[c==#2], que es 1si es cigual al carácter de entrada y de lo 0contrario. Luego Maxextrae la respuesta.

Japt , 20 18 15 bytes

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

Pruébalo en línea!

Guardado 5 bytes gracias a obarakon y ETHproductions

Python , 38 bytes

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

Pruébalo en línea!

Dennis ahorró 3 bytes actualizando ca una cadena de caracteres duplicados en lugar de actualizar recursivamente un número para multiplicar cpor.

05AB1E , 11 6 bytes

-5 bytes gracias a carusocomputing

γvy²¢M

Pruébalo en línea!

γ      # 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

Pruébalo en línea!

Ejecutar a través de la cadena y reemplazar el carácter actual con un contador que aumenta cada vez que es igual co restablecer 0si no. Toma el máximo de la lista.

Gracias a @xnor por 4 bytes.

C # 116 115 bytes

Mi primer código golf

Editado porque el envío inicial era un fragmento y faltaba el espacio de nombres requerido para la expresión regular

Edite la reescritura completa n. ° 2 para admitir caracteres con significados especiales de expresiones regulares

usando System.Linq; s => c => System.Text.RegularExpressions.Regex.Replace (s, "[^" + c + "]", ++ c + ""). Split (c) .Max (x => x longitud);

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 bytes

-2 bytes gracias a @Neil
-1 byte gracias a @apsillers

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

Toma entrada en la sintaxis de curry: f("foobar")("o") .

Fragmento de prueba

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>

Otra opción usando evaly for(54 bytes)

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

Respuesta anterior usando 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 72 bytes

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

Fragmento compatible con ES6:

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 devuelve un montón de cadenas vacías y caracteres individuales, así como las ejecuciones, pero esto no afecta el resultado.

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

Pruébalo en línea!

Perl 6 ,  45 43  42 bytes

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

Pruébalo

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

Pruébalo

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

Pruébalo

Expandido:

-> $_, $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

Solución recursiva que trata la entrada de cadena como una matriz (nota: la entrada inicial sigue siendo una cadena) y consume caracteres de izquierda a derecha C:

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

Rastrea la carrera actual ty la mejor globalT .

Explicación:

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`

Ajuste ta falselos no partidos funciona porque cada vez que tse incrementa, falsese trata como 0(es decir, false + 1es 1), y falsenunca se comparará rallador que cualquier valor en el mundial-max T.

Jalea , 5 bytes

=ŒgṀS

Este es un enlace / función diádica que toma una cadena y un carácter. Tenga en cuenta que no puede funcionar como un programa completo, ya que la entrada de los argumentos de la línea de comandos utiliza la sintaxis de Python, y Python, a diferencia de Jelly, no distingue las cadenas de un solo tono de los caracteres.

Pruébalo en línea!

Cómo funciona

=Œ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

Pruébalo en línea!

El primer carácter es el carácter a comprobar.

APL (Dyalog) , 18 11 bytes

Requiere intercambio ⊂con la ⊆versión 16.0 o tener ⎕ML←3(predeterminado en muchos sistemas).

⌈/0,≢¨⊂⍨⎕=⎕

Pruébalo en línea!

⎕=⎕ Booleano para igualdad entre dos entradas

⊂⍨ autopartición (comenzar particiones donde un elemento distinto de cero es mayor que su predecesor)

≢¨ cuenta cada uno

0, anteponer un cero (para los casos de entrada vacía)

⌈/ máximo de esos

Vieja solución

Primero solicita s , luego c

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

Pruébalo en línea!

⎕ solicitud de s

⊢ para eso

(… )⎕S 1PCRE S earch para la duración de las ocurrencias de

 '+' un símbolo más (que significa uno o más)

 ,¨  agregado a cada uno de los elementos de

 ⎕ la c solicitada

0, anteponer un cero (para los casos de entrada vacía)

⌈/ máximo de esos

c debe darse como un vector de 1 elemento de una cadena cerrada si necesita escapar.

PHP, 70 67 bytes

tres versiones:

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;

toma datos de los argumentos de la línea de comandos ejecutarlos -ro probarlos en línea .

PHP , 70 bytes

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

Pruébalo en línea!

PHP , 75 bytes

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

Pruébalo en línea!

PHP , 83 bytes

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

Pruébalo en línea!

+8 bytes para evitar @

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

JavaScript (ES6), 47 40 38 bytes

(Guardado 7 bytes gracias a @Neil, y 2 bytes gracias a @HermanLauenstein.)

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

Explicación:

Busca recursivamente una ejecución más larga hasta que no se encuentre ninguna.

Retazo:

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

Jalea, 10 9 bytes

f⁴L
ŒgÇ€Ṁ

Explicación:

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.

Pruébalo en línea!

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)

Pruébalo en línea!

Haskell , 66 bytes

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

Pruébalo en línea!

Una versión un poco más fácil de leer, sin puntos:

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

Agrupa la cadena por letra, luego filtra por aquellos grupos que contienen el carácter correcto, luego encuentra las longitudes, agrega 0 a la lista de longitudes en caso de que no aparezca y finalmente encuentra el valor máximo.

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

entrada

["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

Pruébalo en línea!

CJam , 20 19 18 16 bytes

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

Pruébalo en línea!

Explicación

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

sdebe ser entrada a A1.
cdebe ser entrada a A2.
La fórmula debe ser una fórmula de matriz ( Ctrl+ Shift+Enter ) que agrega llaves { }.

Técnicamente, esto solo puede manejar donde la ejecución más larga es inferior a 1,048,576 (que es 2 ^ 20) porque así es como las filas que el Excel actual le permitirá tener en una hoja de trabajo. Como carga los más de un millón de valores en la memoria cada vez que recalcula, esta no es una fórmula rápida .

MATL , 15 bytes

0i0v=dfd1L)0hX>

Pruébalo en línea!

El algoritmo básico es muy simple (¡sin uso de división!), Pero tuve que tirar 0i0vy 0hpermitir los casos extremos. Aún así, pensé que el enfoque era bueno, y tal vez todavía pueda encontrar otra técnica para manejar los casos límite: el algoritmo encuentra bien la ejecución más larga en el medio de una cadena, pero no para caracteres individuales o cadenas vacías; Todavía estoy probando si puedo 'rellenar' las variables en mejores lugares para obtener mejores resultados.

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.

No funciona en vacío c. Por otra parte, supongo que cada cadena contiene una serie infinita de cadenas vacías entre cada carácter :)

R , 66 58 bytes

-8 bytes gracias a BLT y MickyT

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

devuelve una función anónima TIO tiene una diferencia de 1 byte porqueel no funciona allí por razones inexplicables.

Pruébalo en línea!

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 gracias a @ OlivierGrégoire

Toma entrada scomo a char[], y ccomo achar

Explicación:

Pruébalo aquí

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

Rubí, 40 bytes.

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

Pruébalo en línea!