Wyzwanie:

Biorąc pod uwagę ciąg znaków podzielony na określone pozycje i wielką literę należy wpisać pierwszy znak danego słowa. Wielką literę pierwszego słowa używaj wielkiej litery, jeśli i tylko jeśli była już wielka

Wejście :

Ciąg si znak c.

Ouput:

Ciąg przy każdym wystąpieniu czastępowany pierwszym znakiem wielkimi literami

Przykłady:

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

Uwaga :

• Podane dane wejściowe zawsze będą ważne. tj.: Pierwszy zawsze będzie ciągiem zawierającym co najmniej jedną instancję znaku do zastąpienia. Drugi zawsze będzie pojedynczą postacią.
• Długość ciągu wejściowego będzie większa 4.

• Będzie co najmniej jedno wystąpienie postaci do podziału.

• Dane wejściowe z pewnością zawierają tylko litery i separator (Dzięki @Arnauld)

• Separator to wszystko, co nie jest alfabetem (az / AZ) (sugerowane przez @Dennis)

Kryteria wygranej:

To jest golf golfowy, więc wygrywa najkrótszy kod w bajtach dla każdego języka.

1. Dzięki @JonathanAllan za wskazanie dwóch błędów.

Python 3 , 63 bajty

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

Wypróbuj online!

C (gcc) , 61 53 55 bajtów

-8 bajtów dzięki Dennisowi!

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

Wypróbuj online!

JavaScript (ES6), 58 56 bajtów

Zaoszczędzono 2 bajty dzięki @ l4m2 / @Downgoat

Pobiera dane wejściowe w składni curry (s)(c).

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

Wypróbuj online!

Skomentował

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 bajtów

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

Wypróbuj online!

sed 4.2.2 (-r), 21

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

Próbowałem \Wzamiast [^a-z], ale niestety to nie pasuje _.

Wypróbuj online!

Galaretka , 8 bajtów

Œt⁸1¦«⁸ḟ

Wypróbuj online!

Jak to działa

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

Oktawa , 83 , 66 , 64 bajtów

Zaoszczędzono 2 bajty dzięki Luisowi Mendo. upperzamiast toupper.

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

Wypróbuj online!

Wow, to chyba najbardziej niechlujny fragment kodu Octave, jaki kiedykolwiek napisałem! Wykorzystuje dwie sztuczki opublikowane w tym pytaniu ze wskazówkami, mianowicie listę argumentów i tablice komórkowe.

Wyjaśnienie:

Wprowadzanie listy argumentów:

@(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))

kjest tutaj pierwszym znakiem spo każdym separatorze c, przekonwertowanym na wielkie litery. Indeks każdej wielkiej litery jest przechowywany w i.

Korpus komórki:

Tworzymy tablicę komórkową z dwoma elementami, z których jeden mówi się, że wszystkie i-te znaki powinny zostać zastąpione przez jego odpowiednik k, a drugi z s, który jest już zaktualizowany. Indeksujemy to za pomocą, {2}aby odzyskać tylko cały zmodyfikowany ciąg znaków. Jest on podawany do strsplit, który dzieli go na komórki o znaku separatora. Konwertujemy go na listę oddzieloną przecinkami za pomocą {:}i konkatenujemy z powrotem do ciągu za pomocą nawiasów kwadratowych [].

Przepraszam, jeśli to nie miało dla ciebie sensu ... Dla mnie to nie ma sensu: P.

Retina 0.8.2 , 20 bajtów

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

Wypróbuj online! Bierze tylko ciąg, separator opcjonalny. Wszystkie znaki niealfabetyczne są usuwane, ale każdy następny znak alfabetyczny jest pisany wielkimi literami. Poprzednia 34-bajtowa wersja zaakceptowała dowolne dane wejściowe:

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

Wypróbuj online! Link zawiera pakiet testowy. Zakłada, że ​​dane wejściowe składają się z łańcucha i znaku połączonych razem. Objaśnienie: Pierwszy etap transliteruje wszystkie znaki bezpośrednio po wystąpieniu znaku końcowego od małych do wielkich liter, a drugi etap następnie usuwa wszystkie wystąpienia znaku końcowego.

W obu rozwiązaniach +działa również dopasowanie od prawej do lewej zamiast .

APL (Dyalog Classic) , 22 bajty

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

Wypróbuj online!

Röda , 57 54 bajtów

-3 bajty dzięki kwakowi krów

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

Wypróbuj online!

Wyjaśnienie:

{
  (_/`\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 bajtów

Zapisano 1 bajt bez użycia argumentu

ÓÁˆ/õ±

Wypróbuj online!

Program przyjmuje tekst jako dane wejściowe, a znak jako argument.

Hexdump:

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

To prosta zamiana. Nieskompresowany wygląda następująco

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

Wykonaj podstawienie globalne, w którym \Aznak niealfabetyczny, a następnie znak (.)zostanie zastąpiony \upierwszą grupą przechwytywania zapisaną dużymi literami\1

Scala, 83 bajty

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

Wypróbuj online!

Wyjaśnienie:

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

Czerwony , 87 bajtów

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

Wypróbuj online!

05AB1E , 9 bajtów

¡ćsvyćusJ

Wypróbuj online!

Wyjaśnienie

¡           # 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 bajtów

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

Run with -r. Was 2 bytes shorter using split instead of explode, but ^ test fails due to regex.

-8 thanks to Med

Groovy, 43 bytes, 45 bytes

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

Try it online. Test suite included excluding the last item as it lacks the separator char c.

Go, 138 92 87 bytes

Dropped 46 bytes thanks to @Dennis' title case idea.

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

Try it online!

Husk, 10 bytes

ΣΓ·:mΓo:ax

Try it online!

Explanation

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

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

Try it online.

Explanation:

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)

Try it online!

Uses this trick can can not be properly executed in TIO so I simulated it.

We need the T otherwise one of the test cases fails.

Stax, 11 bytes

óKo{cplòüö\

Run and debug it

Explanation

/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

There's a few parts I would really like to fix somehow. I can get it down to about 8 bytes, but it fails on the last test case >.<

Ruby -pl, 36 bytes

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

Try it online!

Takes only the string without second argument. Uses the block version of gsub! method because with common gsub! x,y syntax $1 is not readily filled with match data. |$ in regex is necessary for the test case with separator in the end.

Python 3, 77 bytes

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

Try it online!

This assumes that the string is ASCII encoded and assumes that s and c are preloaded variables containing the input.

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

This solution works on the fact that in ASCII encoding, lowercase letters are positioned 32 entries after capitalised letters

Edit: i just realised that this also capitalises the first character in the string, which it shouldn't. but i'm quite proud of my nonsense, so i'll leave this up if that's allowed