挑战：

给定字符串在特定位置处分开，并大写给定单词的第一个字符。当且仅当第一个单词的大写字母已经被大写时，才将其大写

输入：

字符串s和字符c。

：

每次出现的字符串都c被替换为首个大写的char

例子 ：

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

注意 ：

• 给定的输入将始终有效。ie：第一个将始终是一个字符串，至少包含一个要替换的字符实例。第二个将始终是单个字符。
• 输入字符串的长度将大于4。

• 至少有一次出现该字符的情况。

• 确保输入仅包含字母和分隔符（感谢@Arnauld）

• 分隔符是不是字母（az / AZ）的任何东西（@Dennis建议）

获奖标准：

这是代码高尔夫球，因此每种语言的最短代码（以字节为单位）获胜。

1. 感谢@JonathanAllan指出了两个错误。

Python 3，63字节

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

在线尝试！

C（gcc），61 53 55字节

-8个字节感谢丹尼斯！

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

在线尝试！

JavaScript（ES6），58 56字节

@ l4m2 / @Downgoat节省了2个字节

以currying语法接受输入(s)(c)。

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

在线尝试！

已评论

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，19个 -p字节

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

在线尝试！

sed 4.2.2（-r），21

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

我尝试\W代替[^a-z]，但是不幸的是不匹配_。

在线尝试！

果冻，8字节

Œt⁸1¦«⁸ḟ

在线尝试！

怎么运行的

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

八度，83，66，64个字节

感谢Luis Mendo，节省了2个字节。upper代替toupper。

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

在线尝试！

哇，这可能是我写过的最混乱的八度代码了！这将使用两个招数张贴在此提示问题中技巧，即参数列表和单元格数组。

说明：

参数列表输入：

@(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是s每个分隔符之后的第一个字符c，转换为大写。每个大写字符的索引存储在中i。

单元阵列主体：

我们创建了一个包含两个元素的单元格数组，一个是我们说所有第i个字符都应替换为中的第i个字符k，另一个是使用s，现在已经更新了。我们使用索引该索引，{2}以便仅返回整个修改后的字符串。strsplit将其馈入，将其在分隔符处拆分为单元格。我们使用将其转换为逗号分隔的列表{:}，并使用方括号将其连接回字符串[]。

道歉，如果这对您没有任何意义...对我来说几乎没有道理：P

视网膜0.8.2，20字节

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

在线尝试！仅采用字符串，分隔符为可选。删除所有非字母字符，但随后的任何字母字符均大写。先前的34字节版本接受任意输入：

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

在线尝试！链接包括测试套件。假设输入由串联在一起的字符串和字符组成。说明：第一级在出现结束字符后立即将所有字符从小写转换为大写，然后第二阶段删除所有出现的结束字符。

对于这两种解决方案，也可以使用从右到左的匹配代替+。

APL（Dyalog Classic），22字节

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

在线尝试！

Röda，57 54字节

牛嘎嘎声 -3个字节

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

在线尝试！

说明：

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

不使用参数保存1个字节

ÓÁˆ/õ±

在线尝试！

该程序将文本作为输入，并将char作为参数。

十六进制转储：

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

这是一个简单的替代。未压缩，如下所示

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

执行全局替换，其中用大写的第一个捕获组替换\A一个非字母字符，后跟一个字符(.)\u\1

Scala，83个字节

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

在线尝试！

说明：

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

红色，87字节

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

在线尝试！

05AB1E，9个字节

¡ćsvyćusJ

在线尝试！

说明

¡           # 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字节

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

用运行-r。使用split而不是explode缩短了2个字节，但是^测试由于正则表达式而失败。

-8感谢Med

Groovy，43个字节，45个字节

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

在线尝试。测试套件包括排除最后一个项目，因为它缺少分隔符char c。

Go，138 92 87字节

由于@Dennis的标题大小写的想法，丢弃了46个字节。

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

在线尝试！

外壳，10字节

ΣΓ·:mΓo:ax

在线尝试！

说明

ΣΓ·: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＃（单声道），122字节

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

在线尝试！

Java 10，141个字节

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

在线尝试。

说明：

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字节

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

在线尝试！

使用此技巧无法在TIO中正确执行，因此我对其进行了模拟。

我们需要T否则测试案例之一将失败。

Stax，11 个字节

óKo{cplòüö\

运行并调试

说明

/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

我确实想以某些方式修复某些部分。我可以将其压缩到大约8个字节，但是在最后一个测试用例>。<上失败了。

红宝石 -pl，36个字节

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

在线尝试！

仅接受不带第二个参数的字符串。使用gsub!方法的块版本，因为使用通用gsub! x,y语法$1不容易用匹配数据填充。|$对于最后带有分隔符的测试用例，在regex中是必需的。

Python 3，77个字节

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

在线尝试！

这假定字符串是ASCII编码的，并且假定s和c是包含输入的预加载变量。

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

此解决方案基于以下事实：在ASCII编码中，小写字母位于大写字母之后的32个条目中

编辑：我只是意识到这也将字符串中的第一个字符大写，这是不应该的。但我为我的废话感到骄傲，所以如果允许的话，我会放弃