Sfida:

Dato una stringa divisa in posizioni specifiche e capitalizza il primo carattere di una determinata parola. Scrivi in ​​maiuscolo il primo carattere della prima parola se e solo se era già in maiuscolo

Input:

Una stringa se un carattere c.

Uscita:

La stringa con ogni occorrenza di csostituita con il primo carattere in maiuscolo

Esempi:

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 :

• I dati forniti saranno sempre validi. vale a dire: la prima sarà sempre una stringa con almeno un'istanza del carattere da sostituire in. Il secondo sarà sempre un singolo personaggio.
• La lunghezza della stringa di input sarà maggiore 4.

• Ci sarà almeno un'occorrenza del personaggio in cui dividere.

• L'ingresso è garantito per contenere solo lettere e il separatore (Grazie @Arnauld)

• Il separatore è tutto ciò che non è un alfabeto (az / AZ) (suggerito da @Dennis)

Criteri vincenti:

Questo è code-golf, quindi il codice più breve in byte per ogni lingua vince.

1. Grazie a @JonathanAllan per aver segnalato due errori.

Python 3 , 63 byte

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

Provalo online!

C (gcc) , 61 53 55 byte

-8 byte grazie a Dennis!

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

Provalo online!

JavaScript (ES6), 58 56 byte

Salvato 2 byte grazie a @ l4m2 / @Downgoat

Accetta input nella sintassi del curry (s)(c).

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

Provalo online!

Commentate

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 byte

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

Provalo online!

sed 4.2.2 (-r), 21

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

Ho provato \Winvece di [^a-z], ma purtroppo non corrisponde _.

Provalo online!

Gelatina , 8 byte

Œt⁸1¦«⁸ḟ

Provalo online!

Come funziona

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

Octave , 83 , 66 , 64 byte

Salvato 2 byte grazie a Luis Mendo. upperinvece di toupper.

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

Provalo online!

Wow, questo è probabilmente il pezzo di codice di ottava più complicato che abbia mai scritto! Questo utilizza due dei trucchi pubblicati in questo domanda di suggerimenti, vale a dire l'elenco degli argomenti e gli array di celle.

Spiegazione:

Input elenco argomenti:

@(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è qui il primo carattere sdopo ogni separatore c, convertito in maiuscolo. L'indice di ogni carattere in maiuscolo è memorizzato in i.

Corpo dell'array cellulare:

Creiamo un array di celle con due elementi, uno in cui diciamo che tutti i suoi caratteri dovrebbero essere sostituiti dalla sua controparte in k, e l'altro con s, che è ora già aggiornato. Lo indicizziamo usando in {2}modo tale da recuperare solo l'intera stringa modificata. Questo è alimentato strsplit, che lo divide in celle in corrispondenza del carattere separatore. Lo convertiamo in un elenco separato da virgole usando {:}e lo concateniamo in una stringa usando parentesi quadre [].

Ci scusiamo se per te non ha avuto alcun senso ... Per me ha poco senso: P

Retina 0.8.2 , 20 byte

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

Provalo online! Accetta solo la stringa, separatore opzionale. Tutti i caratteri non alfabetici vengono eliminati ma tutti i seguenti caratteri alfabetici vengono maiuscoli. La precedente versione a 34 byte ha accettato l'input arbitrario:

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

Provalo online! Il link include la suite di test. Presuppone che l'input sia costituito dalla stringa e dal carattere concatenati insieme. Spiegazione: Il primo stadio traduce immediatamente tutti i caratteri che seguono le occorrenze del carattere finale dal maiuscolo al maiuscolo e il secondo stadio cancella quindi tutte le occorrenze del carattere finale.

Per entrambe le soluzioni, utilizzare anche una corrispondenza da destra a sinistra anziché una +funziona.

APL (Dyalog Classic) , 22 byte

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

Provalo online!

Röda , 57 54 byte

-3 byte grazie al ciarlatano Cows

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

Provalo online!

Spiegazione:

{
  (_/`\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 byte

1 byte salvato non usando l'argomento

ÓÁˆ/õ±

Provalo online!

Il programma accetta il testo come input e il carattere come argomento.

hexdump:

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

Questa è una semplice sostituzione. Non compresso, sembra il seguente

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

Esegui una sostituzione globale in cui \A, un carattere non alfabetico, seguito da un carattere (.)viene sostituito con il \uprimo gruppo di acquisizione maiuscolo\1

Scala, 83 byte

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

Provalo online!

Spiegazione:

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

Rosso , 87 byte

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

Provalo online!

05AB1E , 9 byte

¡ćsvyćusJ

Provalo online!

Spiegazione

¡           # 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 byte

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

Corri con -r . È stato più corto di 2 byte usando split anziché esplode, ma ^ test fallisce a causa di regex.

-8 grazie a Med

Groovy, 43 byte, 45 byte

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

Provalo online . Suite di test inclusa escluso l'ultimo elemento in quanto privo del carattere separatore c.

Vai, 138 92 87 byte

Dropped 46 byte grazie all'idea del caso del titolo @Dennis .

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

Provalo online!

Buccia , 10 byte

ΣΓ·:mΓo:ax

Provalo online!

Spiegazione

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

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

Provalo online!

Java 10, 141 byte

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

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

Usa questo trucco non può essere eseguito correttamente in TIO, quindi l'ho simulato.

Abbiamo bisogno che Taltrimenti uno dei casi di test fallisca.

Stax , 11 byte

óKo{cplòüö\

Esegui ed esegui il debug

Spiegazione

/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

Ci sono alcune parti che vorrei davvero aggiustare in qualche modo. Posso ottenere fino a circa 8 byte, ma non riesce sull'ultimo caso di test>. <

Rubino -pl , 36 byte

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

Provalo online!

Accetta solo la stringa senza secondo argomento. Utilizza la versione a blocchi del gsub!metodo perché con la gsub! x,ysintassi comune $1non viene prontamente riempito con i dati delle corrispondenze. |$in regex è necessario per il test case con separatore alla fine.

Python 3 , 77 byte

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

Provalo online!

Questo presuppone che la stringa viene codificato ASCII e presuppone che se csono precaricati variabili contenenti l'ingresso.

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

Questa soluzione si basa sul fatto che nella codifica ASCII, le lettere minuscole sono posizionate 32 voci dopo lettere maiuscole

Modifica: mi sono appena reso conto che anche questo rende maiuscolo il primo carattere della stringa, cosa che non dovrebbe. ma sono abbastanza orgoglioso delle mie sciocchezze, quindi lascio perdere questo se ciò è permesso