Desafio:

Dada uma sequência de caracteres em posições específicas e colocar em maiúscula o primeiro caractere da palavra especificada. Coloque em maiúscula o primeiro caractere da primeira palavra se, e somente se, já estiver em maiúscula

Entrada :

Uma string se um personagem c.

Ouput:

A sequência com cada ocorrência de csubstituída pelo primeiro caracter maiúsculo

Exemplos :

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 :

• A entrada fornecida sempre será válida. ou seja: o primeiro sempre será uma string com pelo menos uma instância do caractere a ser substituída em. O segundo sempre será um único personagem.
• O comprimento da sequência de entrada será maior 4.

• Haverá pelo menos uma ocorrência do personagem para dividir.

• É garantido que a entrada contenha apenas letras e o separador (Obrigado @Arnauld)

• Separador é qualquer coisa que não seja um alfabeto (az / AZ) (sugerido por @Dennis)

Critérios de vitória:

Este é o código-golfe, pelo que o código mais curto em bytes para cada idioma vence.

1. Agradecemos a JonathanAllan por apontar dois erros.

Python 3 , 63 bytes

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

Experimente online!

C (gcc) , 61 53 55 bytes

-8 bytes graças ao Dennis!

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

Experimente online!

JavaScript (ES6), 58 56 bytes

Economizou 2 bytes graças a @ l4m2 / @Downgoat

Recebe entrada na sintaxe de currying (s)(c).

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

Experimente online!

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

Experimente online!

sed 4.2.2 (-r), 21

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

Tentei em \Wvez de [^a-z], mas infelizmente isso não corresponde _.

Experimente online!

Geléia , 8 bytes

Œt⁸1¦«⁸ḟ

Experimente online!

Como 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.

Oitava , 83 , 66 , 64 bytes

Economizou 2 bytes graças a Luis Mendo. upperao invés detoupper .

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

Experimente online!

Uau, essa é provavelmente a parte mais confusa do código Oitava que eu já escrevi! Isso usa dois dos truques publicados em nesta pergunta, como a lista de argumentos e as matrizes de células.

Explicação:

Entrada da 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))

ké aqui o primeiro caractere sapós cada separador c, convertido para maiúsculas. O índice de cada caractere maiúsculo é armazenado i.

Corpo da matriz celular:

Criamos uma matriz de células com dois elementos, um onde dizemos que todos os i-ésésimos caracteres devem ser substituídos por sua contraparte ke a outra com s, que já está atualizada. Nós indexamos isso usando {2}para que apenas recuperemos toda a string modificada. Isso é alimentado strsplit, o que o divide em células no caractere separador. Nós o convertemos em uma lista separada por vírgulas usando {:}e concatenamos de volta em uma string usando colchetes [].

Desculpas se isso não fez sentido para você ... Quase não faz sentido para mim: P

Retina 0.8.2 , 20 bytes

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

Experimente online! Pega apenas a sequência, separador opcional. Todos os caracteres não alfabéticos são excluídos, mas qualquer caractere alfabético a seguir está em maiúsculas. A versão anterior de 34 bytes aceitou entrada arbitrária:

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

Experimente online! O link inclui o conjunto de testes. Assume que a entrada consiste na sequência e no caracter concatenados juntos. Explicação: O primeiro estágio translitera todos os caracteres imediatamente após as ocorrências do caractere final de minúsculas para maiúsculas e o segundo estágio exclui todas as ocorrências do caractere final.

Para ambas as soluções, usar uma correspondência da direita para a esquerda em vez de uma +também funciona.

APL (Dyalog Classic) , 22 bytes

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

Experimente online!

Röda , 57 54 bytes

-3 bytes graças ao vacas charlatão

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

Experimente online!

Explicação:

{
  (_/`\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 salvo por não usar argumento

ÓÁˆ/õ±

Experimente online!

O programa recebe o texto como entrada e o char como argumento.

Hexdump:

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

Esta é uma substituição simples. Descompactado, parece o seguinte

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

Executar uma substituição global na qual \Aum caractere não alfabético, seguido por um caractere, (.)é substituído pelo \uprimeiro grupo de captura em maiúsculas\1

Scala, 83 bytes

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

Experimente online!

Explicação:

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

Vermelho , 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]]]

Experimente online!

05AB1E , 9 bytes

¡ćsvyćusJ

Experimente online!

Explicação

¡           # 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);

Corra com -r. Foi 2 bytes mais curto usando divisão em vez de explosão, mas ^ teste falhou devido à regex.

-8 graças a Med

Groovy, 43 bytes, 45 bytes

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

Experimente online . O conjunto de testes incluiu a exclusão do último item, pois não possui o caractere separador c.

Go, 138 92 87 bytes

Foram eliminados 46 bytes graças à ideia de capa de título do @Dennis .

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

Experimente online!

Casca , 10 bytes

ΣΓ·:mΓo:ax

Experimente online!

Explicação

ΣΓ·: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

Experimente online!

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

Experimente online.

Explicação:

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)

Experimente online!

O uso desse truque não pode ser executado corretamente no TIO, então eu o simulei.

Precisamos do Tcaso contrário, um dos casos de teste falhará.

Stax , 11 bytes

óKo{cplòüö\

Execute e depure

Explicação

/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

Há algumas partes que eu realmente gostaria de consertar de alguma forma. Posso reduzi-lo para cerca de 8 bytes, mas falha no último caso de teste>. <

Ruby -pl , 36 bytes

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

Experimente online!

Pega apenas a cadeia sem segundo argumento. Usa a versão em bloco do gsub!método porque, com gsub! x,ysintaxe comum, $1não é facilmente preenchida com dados de correspondência. |$em regex é necessário para o caso de teste com separador no final.

Python 3 , 77 bytes

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

Experimente online!

Isso pressupõe que a sequência seja codificada em ASCII e assume que se csão variáveis ​​pré-carregadas que contêm a entrada.

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

Essa solução funciona no fato de que, na codificação ASCII, letras minúsculas são posicionadas 32 entradas após as letras maiúsculas

Edit: acabei de perceber que isso também coloca em maiúscula o primeiro caractere da string, o que não deveria. mas tenho muito orgulho das minhas bobagens, então deixarei isso se for permitido