Desafío :

Dada una cadena dividida en posiciones específicas y capitalizar el primer carácter de la palabra dada. Poner en mayúscula el primer carácter de la primera palabra si y solo si ya estaba en mayúscula

Entrada:

Una cadena sy un personaje c.

Ouput:

La cadena con cada aparición de creemplazado con el primer carácter en mayúscula

Ejemplos:

STRING(s)             CHARACTER(c)  RESULT
Hello_world           _             HelloWorld
me,no,like            ,             meNoLike
you-got-it            -             youGotIt
Am^I^clear            ^             AmIClear
go!full!caps          !             goFullCaps
weird&but&tRue        &             weirdButTRue
ProbleM1fixed1no      1             ProbleMFixedNo
!prob!!lem!s!Olved!!  !             ProbLemSOlved

Nota :

• La entrada dada siempre será válida. es decir: el primero siempre será una cadena con al menos una instancia del carácter para reemplazar en. El segundo siempre será un solo personaje.
• La longitud de la cadena de entrada será mayor 4.

• Habrá al menos una aparición del personaje para dividir.

• La entrada está garantizada para contener solo letras y el separador (Gracias @Arnauld)

• El separador es cualquier cosa que no sea un alfabeto (az / AZ) (sugerido por @Dennis)

Criterios ganadores:

Este es el código de golf, por lo que gana el código más corto en bytes para cada idioma.

1. Gracias a @JonathanAllan por señalar dos errores.

Python 3 , 63 bytes

lambda s,c:''.join(map(min,s,s[0]+s.title()[1:])).replace(c,'')

Pruébalo en línea!

C (gcc) , 61 53 55 bytes

-8 bytes gracias a Dennis!

f(s,c)char*s;{for(;*s;putchar(*s++))if(*s==c)*++s&=95;}

Pruébalo en línea!

JavaScript (ES6), 58 56 bytes

Guardado 2 bytes gracias a @ l4m2 / @Downgoat

Toma entrada en la sintaxis de curry (s)(c).

s=>c=>s.replace(u=/./g,x=>u=x==c?'':u?x:x.toUpperCase())

Pruébalo en línea!

Comentado

s => c =>                  // given s and c
  s.replace(u = /./g, x => // initialize u to a RegExp; replace each character x in s with,
    u =                    // and update u to:
      x == c ?             //   if x is the separator:
        ''                 //     an empty string
      :                    //   else:
        u ?                //     if u is not an empty string:
          x                //       x unchanged
        :                  //     else:
          x.toUpperCase()  //       x capitalized
  )                        // end of replace()

Perl 6 -p , 19 bytes

s:g[<:!L>(.)]=$0.uc

Pruébalo en línea!

sed 4.2.2 (-r), 21

s/[^a-z]+(.)?/\u\1/gi

Lo intenté en \Wlugar de [^a-z], pero desafortunadamente eso no coincide _.

Pruébalo en línea!

Jalea , 8 bytes

Œt⁸1¦«⁸ḟ

Pruébalo en línea!

Cómo funciona

Œt⁸1¦«⁸ḟ  Main link. Left argument: s (string). Right argument: c (character).

Œt        Title case; capitalize the first character of each word.
  ⁸1¦     Replace the first character of the result with the first character of s.
     «⁸   Take the character-wise minimum of the result and s.
          Note that uppercase letters have lower code points than lowercase ones.
       ḟ  Filterfalse; remove all occurrences of c.

Octava , 83 , 66 , 64 bytes

Guardado 2 bytes gracias a Luis Mendo. upperen lugar de toupper.

@(s,c,k=upper(s(i=find(s==c)+1)))[strsplit({s(i)=k,s}{2},c){:}];

Pruébalo en línea!

¡Guau, esa es probablemente la pieza más desordenada de código de octava que he escrito! Utiliza dos de los trucos publicados en esta pregunta de consejos, a saber, la lista de argumentos y las matrices de celdas.

Explicación:

Entrada de lista de argumentos:

@(s,c,k        % An anonymous function that may take three input variables, s, c, k
               % where the third argument has the default value:
 k=upper(s(i=find(s==c)+1))

kAquí está el primer carácter sdespués de cada separador c, convertido a mayúsculas. El índice de cada carácter en mayúscula se almacena en i.

Cuerpo de matriz de células:

Creamos una matriz de celdas con dos elementos, uno donde decimos que todos los i-ésimos caracteres deben ser sustituidos por su contraparte en k, y el otro con s, que ahora ya está actualizado. Indexamos esto usando {2}para que solo recuperemos toda la cadena modificada. Esto se alimenta strsplit, lo que lo divide en celdas en el carácter separador. Lo convertimos en una lista separada por comas usando {:}, y lo concatena nuevamente en una cadena usando corchetes [].

Disculpas si eso no tiene ningún sentido para ti ... Apenas tiene sentido para mí: P

Retina 0.8.2 , 20 bytes

T`lLp`LL_`[\W\d_]+.?

Pruébalo en línea! Solo toma la cuerda, separador opcional. Todos los caracteres no alfabéticos se eliminan, pero los siguientes caracteres alfabéticos están en mayúsculas. La versión anterior de 34 bytes aceptaba entradas arbitrarias:

T`l`L`(?=.*(.)$)\1+.
(?=.*(.)$)\1

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Asume que la entrada consiste en la cadena y el carácter concatenados juntos. Explicación: La primera etapa translitera todos los caracteres inmediatamente después de las ocurrencias del carácter final de minúsculas a mayúsculas y la segunda etapa luego elimina todas las ocurrencias del carácter final.

Para ambas soluciones, usar una coincidencia de derecha a izquierda en lugar de a +también funciona.

APL (Dyalog Classic) , 22 bytes

{⍵~⍨1(819⌶@(⍵=¯1⌽⊢))⍺}

Pruébalo en línea!

röda , 57 54 bytes

-3 bytes gracias al graznido de las vacas

{(_/`\Q$_`)|{pull;[upperCase(_[:1]),_1[1:]]if[#_1>0]}}

Pruébalo en línea!

Explicación:

{
  (_/`\Q$_`)| /* Pull two strings and split the first with the second */
  {
    pull;                /* Pull one string and print it */
                         /* For each string _1 in the stream: */
                         /*   If _1 is not empty: */
    [                    /*     Print: */
      upperCase(_[:1]),  /*       The first character capitalized */
      _1[1:]             /*       The rest of characters */
    ]if[#_1>0]           /*   End if */
  }
}

V , 6 7 bytes

1 byte guardado al no usar argumento

ÓÁˆ/õ±

Pruébalo en línea!

El programa toma el texto como entrada y el carácter como argumento.

Hexdump:

00000000: d3c1 882f f5b1                           .../..

Esta es una simple sustitución. Sin comprimir, se parece a lo siguiente

:s/\A(.)/\u\1/g

Realice una sustitución global en la cual \A, un carácter no alfabético, seguido de un carácter (.)se reemplaza con el \uprimer grupo de captura en mayúsculas\1

Scala, 83 bytes

def f(s:String)={val w=s.split("[^a-zA-Z]");w(0)+w.tail.map(_.capitalize).mkString}

Pruébalo en línea!

Explicación:

def f(s: String) = {                        // takes a String "s" as input
  val w = s.split("[^a-zA-Z]");             // split on non-alpha chars
  w(0) + w.tail.map(_.capitalize).mkString  // upper case first letter of all words except first one and join array into a String
}                                           //

Rojo , 87 bytes

func[s c][b: split s c prin b/1 foreach w next b[if w <>""[w/1: uppercase w/1 prin w]]]

Pruébalo en línea!

05AB1E , 9 bytes

¡ćsvyćusJ

Pruébalo en línea!

Explicación

¡           # split the string on the char
 ć          # extract the head of the resulting list
  s         # swap the head to the bottom of the stack
   vy       # for each string y in the rest of the list
     ću     # extract the head and capitalize it
       s    # swap it below the rest of the string
        J   # join everything to one string

PHP, 91 83 bytes

$a=explode($argv[2],$argv[1]);echo array_shift($a);foreach($a as$i)echo ucfirst($i);

Corre con -r. Era 2 bytes más corto usando dividir en lugar de explotar, pero ^ la prueba falla debido a la expresión regular.

-8 gracias a Med

Groovy, 43 bytes, 45 bytes

s.replaceAll(/\$c(.)/){it[1].toUpperCase()}

Pruébalo en línea . Paquete de prueba incluido excluyendo el último elemento ya que carece del separador de caracteres c.

Ir, 138 92 87 bytes

Se eliminaron 46 bytes gracias a la idea del caso del título de @Dennis .

func f(s,d string){p:=Split(s,d);Print(p[0]+Replace(Title(Join(p[1:]," "))," ","",-1))}

Pruébalo en línea!

Casco , 10 bytes

ΣΓ·:mΓo:ax

Pruébalo en línea!

Explicación

ΣΓ·:mΓ(:a)x  -- example inputs: 'x' "abxbcxcdxdex"
          x  -- split on character: ["ab","bc","cd","de"]
 Γ           -- pattern match (x = head) (xs = tail) and do..
  ·:         -- | construct list (x:xs) but with the second argument do..
    m        -- | | map (eg. "bc")
     Γ(  )   -- | | | pattern match on first character
      ( a)   -- | | | | upper-case it
      (: )   -- | | | | and join again
             -- | | | : "Bc"
             -- | | : ["Bc","Cd","De"]
             -- : ["ab","Bc","Cd","De"]
Σ            -- concatenate: "abBcCdDe"

F # (Mono) , 122 bytes

let f(s:string)c=s|>Seq.mapi(fun i x->if i>0&&s.[i-1]=c then Char.ToUpper(x)else x)|>Seq.where((<>)c)|>Seq.toArray|>String

Pruébalo en línea!

Java 10, 141 bytes

s->c->{var r=s.split("\\"+c);var r=a[0],t;for(int i=0;++i<a.length;r+=t.isEmpty()?"":(char)(t.charAt(0)&~32)+t.substring(1))t=a[i];return r;}

Pruébalo en línea.

Explicación:

s->c->{                    // Method with String and character parameters and String return-type
  var r=s.split("\\"+c);   //  Split String by character (with potential regex char)
  var r=a[0],              //  Result-String, starting at the first item
      t;                   //  Temp-String to reduce bytes
  for(int i=0;++i<a.length;//  Loop in the range [1, length_of_array)
      r+=                  //    After every iteration: append the result-String with:
         t.isEmpty()?      //     If the current item empty:
          ""               //      Append nothing
         :                 //     Else:
          (char)(t.charAt(0)&~32)
                           //      Capitalize the first character
          +t.substring(1)) //     And append the other characters as is
    t=a[i];                //   Set `t` to the current String-item of the array
  return r;}               //  Return the result-String

R , 87 bytes

g<-function(s,x,z=strsplit(s,x,T)[[1]])cat(z[1],capwords(z[-1]),sep="")
example(chartr)

Pruébalo en línea!

Utiliza este truco que no se puede ejecutar correctamente en TIO, así que lo simulé.

Necesitamos lo Tcontrario, uno de los casos de prueba falla.

Stax , 11 bytes

óKo{cplòüö\

Ejecutar y depurarlo

Explicación

/BsF1:/s^s|dl                 # Full Program, unpacked, Implicit Input
/                             # Split on substrings (Split input with symbol to split on)
 B                            # Remove first element from array. Push the tail of the array, then the removed element.
  s                           # Swap first two elements of stack
   F                          # Start for loop
    1:/                       # Split array at index; push both parts.
       s^s                    # Swap first two elements of stack, capitalize character, swap first two elements 
         |dl                  # Get length of stack, listify that amount (entire stack), implicit output of array

Hay algunas partes que realmente me gustaría arreglar de alguna manera. Puedo reducirlo a unos 8 bytes, pero falla en el último caso de prueba>. <

Ruby -pl , 36 bytes

$_.gsub!(/[^a-z]+(.|$)/i){$1.upcase}

Pruébalo en línea!

Toma solo la cadena sin segundo argumento. Utiliza la versión de bloque del gsub!método porque con la gsub! x,ysintaxis común $1no se llena fácilmente con datos de coincidencia. |$en regex es necesario para el caso de prueba con separador al final.

Python 3 , 77 bytes

o=[]
for x in s.split(c): o.append(chr(ord(x[0])-32)+x[1:])
print(''.join(o))

Pruébalo en línea!

Esto supone que la cadena está codificada en ASCII y se supone que sy cson variables que contienen la entrada precargado.

for x in s.split(x)       #loop through items in the string s split by x
    o.append(             #add the following to c
        chr(              #turn the following number into a character
            ord(          #turn the following character into a number
                x[0]      #the first character in string x
            )-32          #subtract 32 from this number
        +x[1:]            #add everything past and including the second character in string x

Esta solución funciona sobre el hecho de que en la codificación ASCII, las letras minúsculas se colocan 32 entradas después de las letras mayúsculas

Editar: me acabo de dar cuenta de que esto también capitaliza el primer carácter de la cadena, que no debería. pero estoy bastante orgulloso de mis tonterías, así que lo dejaré si eso está permitido