挑战

前几天，我在阅读Google的Java样式指南，偶然发现了他们的算法，可以将任意字符串转换为camelCase表示法。在此挑战中，您必须实现此算法，因为当您将超级竞争的Java提交编写为代码高尔夫球挑战时，您不想在头脑中做所有这些事情。

注意：我对算法做了一些小的调整。您需要使用以下指定的一种。

算法

您从任意输入字符串开始，并对它应用以下操作：

1. 删除所有撇号 `'
2. 通过在处拆分将结果拆分为单词
   • 不是字母数字和数字的字符 [^a-zA-Z0-9]
   • 大写字母，两侧均用小写字母包围。abcDefGhI jk例如产量abc Def Ghi jk
3. 每个单词都小写。
4. 除第一个单词外，每个单词的第一个字符均大写。
5. 将所有单词重新组合在一起。

附加条款

• 输入将仅包含可打印的ASCII。
• 如果数字是单词中的第一个字母，请保持原样，并且不要使该单词中的其他内容成大写字母。
• 输入将始终至少包含一个字符。

规则

• 允许功能或完整程序。
• 输入/输出的默认规则。
• 有标准漏洞。
• 这是代码高尔夫球，因此最低字节数获胜。Tiebreaker是较早提交的内容。

测试用例

“编程难题和代码高尔夫”->“ programmingPuzzlesCodeGolf”
“ XML HTTP请求”->“ xmlHttpRequest”
“在iOS上支持IPv6吗？” ->“ supportsIpv6OnIos”
“某物，载脂蛋白的残基和标点符号”->“ somethingW1thApostrophesAndPuncTuation”
“没什么特别的”->“没什么特别的”
“ 5pecial ca5e”->“ 5pecialCa5e”
“ 1337”->“ 1337”
“ 1337-spEAk”->“ 1337Speak”
“ whatA混乱”->“ whataMess”
“ abcD”->“ abcd”
“ a”->“ a”
“ B”->“ b”

编码愉快！

视网膜，56字节

字节数假定为ISO 8859-1编码。

T`'\`
S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])
T`L`l
T`l`L`¶.
¶

在线尝试！

说明

这从字面上实现了规范：

T`'\`

除去撇号和反引号。

S_`\W|_|(?<=[a-z])(?=[A-Z][a-z])

将字符串拆分为非单词字符（在正则表达式中也排除数字和下划线），或在下划线或位置的左侧带有小写字母，在右侧带有大写字母，小写字母的位置。当一行中有两个非字母，非数字字符或更重要的字符串时，这将创建一些空段。我们摆脱了那些_选择。在此，“分割”是指将其余各部分放在自己的行上。

T`L`l

将所有内容转换为小写。

T`l`L`¶.

将换行后出现的每个字符转换为大写。由于前面没有换行符，因此可以方便地跳过第一个单词。

¶

摆脱换行符，将所有内容重新组合在一起。

Java，198190字节

+3个字节，因为我忘记了\W+== [^a-zA-Z0-9_]+并且我需要匹配[^a-zA-Z0-9]+

-11字节感谢user20093 - ?:而不是if/else

因为，Java。

s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;}

这是一个lambda。像这样打电话：

UnaryOperator<String> op = s->{String[]a=s.replaceAll("`|'","").split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])");s="";for(String w:a){String t=w.toLowerCase();s+=a[0]==w?t:t.toUpperCase().charAt(0)+t.substring(1);}return s;};
System.out.println(op.apply("Programming Puzzles & Code Golf"));

可读版本：

public static String toCamelCase(String s) {
    String[] tokens = s
            .replaceAll("`|'", "") // 1. Remove all apostrophes
            .split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])"); // 2. Split on [\W_]+ or between [a-z] and [A-Z][a-z]
    s = ""; // Reusing s for building output is cheap
    for (String token : tokens) {
        String lowercaseToken = token.toLowerCase(); // 3. Lowercase every word
        s += tokens[0].equals(token)?lowercaseToken:lowercaseToken.toUpperCase().charAt(0) + lowercaseToken.substring(1); // 4. Uppercase first char of all but first word
        // ^ 5. Join all words back together
    }
    return s;
}

的JavaScript（ES6），156 154 152 148 145 141 140个字节

感谢@Neil（6个字节），@ ETHproductions（3个字节）和@ edc65（7个字节）

a=>a[r='replace'](/`|'/g,a='')[r](/[a-z](?=[A-Z][a-z])/g,'$& ')[r](/[^\W_]+/g,b=>a+=(a?b[0].toUpperCase():'')+b.slice(!!a).toLowerCase())&&a

删除撇号，然后进行替换以分割特殊字符/在大写字母之前，然后与适当的大小写合并。不幸的是，toLowerCase()和toUpperCase()是烦人长，难以避免在这里...

vim，69 68 66

:s/[`']//g<cr>:s/[a-z]\zs\ze[A-Z][a-z]\|\W\|_/\r/g<cr>o<esc>guggj<C-v>GgU:%s/\n<cr>

vim比Perl短吗？这是什么疯狂？

:s/[`']//g<cr>           remove ` and '
:s/                      match...
 [a-z]\zs\ze[A-Z][a-z]   right before a lowercase-surrounded uppercase letter
 \|\W\|_                 or a non-word char or underscore
 /\r/g<cr>               insert newlines between parts
o<esc>                   add an extra line at the end, necessary later...
gugg                     lowercasify everything
j                        go to line 2 (this is why we added the extra line)
<C-v>G                   visual select the first char of all-but-first line
gU                       uppercase
:%s/\n<cr>               join all lines into one

感谢尼尔发现了无用的按键！

Mathematica 10.1，101个字节

""<>(ToCamelCase@{##2}~Prepend~ToLowerCase@#&@@StringCases[StringDelete[#,"`"|"'"],WordCharacter..])&

使用undocumented ToCamelCase，其作用类似于Capitalize但将其他字符设置为小写。

朱莉娅98 89字节

s->lcfirst(join(map(ucfirst,split(replace(s,r"['`]",""),r"[a-z]\K(?=[A-Z][a-z])|\W|_"))))

这是一个匿名函数，它接受一个字符串并返回一个字符串。要调用它，请将其分配给变量。

这里的方法与Doorknob的Perl答案相同：将replace带有空字符串的撇号和反引号split放入匹配必要情况的正则表达式数组中，map该ucfirst函数将每个元素的第一个字母大写，join然后返回数组转换为字符串，然后lcfirst将第一个字符转换为小写的结果。

Perl 67 +1 = 68字节

y/'`//d;s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g;$_=lc;s/^ +| +(.)/\u$1/g

需要-p标志，-l对于多行：

$ perl -pl camelCase.pl input.txt
programmingPuzzlesCodeGolf
xmlHttpRequest
supportsIpv6OnIos:
someThingW1thApostrophesAndPuncTuation
nothingSpecial
5pecialCa5e
1337
1337Speak
abcd

怎么运行的：

y/'`//d;                            # Remove ' and `
s/([a-z](?=[A-Z][a-z]))|\W|_/$1 /g; # Replace according to '2. Split...' this will create
                                    #   a space separated string.
$_=lc;                              # lower case string
s/^ +| +(.)/\u$1/g                  # CamelCase the space separated string and remove any
                                    #   potential leading spaces.

Perl， 87 80 78字节

y/'`//d;$_=join'',map{ucfirst lc}split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;lcfirst

为-p标志添加的字节。

首先，我们使用 y///音译运算符d删除'`输入中的所有字符：

y/'`//d;

然后是代码的内容：

                         split/[a-z]\K(?=[A-Z][a-z])|\W|_/,$_;

（$_使用花式将输入字符串拆分到适当的位置\K匹配字符串中以将其前面的部分排除在实际匹配之外）

          map{ucfirst lc}

（映射字符串的每个拆分部分，并将整个字符串小写，然后将修改后的字符串的第一个字符大写）

$_=join'',

（加入空字符串并重新分配到魔术下划线$_，该下划线将在最后打印出来）

最后，我们通过对正则表达式进行匹配来\l小写第一个字母，并使用带有内置函数的替换字符串，比以前的方法节省2个字节：

lcfirst

感谢@MartinBüttner提供7个字节（[^a-zA-Z\d]-> \W|_）！

Lua，127字节

t=''l=t.lower z=io.read()for x in z:gmatch('%w+')do t=t..(t==''and l(x:sub(1,1))or x:sub(1,1):upper())..l(x:sub(2))end return t

接受来自stdin的字符串并返回驼峰化的结果。

可能仍会寻找更好的解决方案，因为将所有内容存储在变量中感觉效率低下。

但是总的来说，很简单：

 z:gmatch('%w+')

这就是为我节省了一些字节的美。gmatch将根据模式分割字符串：%w+仅字母数字。

之后就是简单的字符串操作。string.upper，string.lower完成。

PHP，145个 122 133字节的

<?=join(split(" ",lcfirst(ucwords(strtolower(preg_replace(["#`|'#","#\W|_#","#([a-z])([A-Z][a-z])#"],[""," ","$1 $2"],$argv[1]))))));

保存到文件，然后从CLI调用。
从单个命令行参数获取输入；必要时转义引号和空格。

分解

<?=                 // 9. print result
join(split(" ",     // 8. remove spaces
    lcfirst(        // 7. lowercase first character
    ucwords(        // 6. uppercase first character in every word
    strtolower(     // 5. lowercase everything
    preg_replace(
        ["#`|'#",   "#\W|_#",   "#([a-z])([A-Z][a-z])#"],
        ["",        " ",        "$1 $2"],
        // 2. replace apostrophes with empty string (remove them)
                    // 3. replace non-word characters with space
                                // 4. insert space before solitude uppercase
        $argv[1]    // 1. take input from command line
    ))))
));

lcfirst允许将其减少为一个命令，节省23个字节。
对于其他替换情况，固定撇号的成本为11个字节。

科特林，160字节

fun a(s: String)=s.replace(Regex("['`]"),"").split(Regex("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")).map{it.toLowerCase().capitalize()}.joinToString("").decapitalize()

我的目标是成为Scala，另一个“替代Java”，因此我对自己的结果感到满意。我从Java答案中窃取了正则表达式。

用以下方法进行测试：

fun main(args: Array<String>) {
    val testCases = arrayOf(
            "Programming Puzzles & Code Golf",
            "XML HTTP request",
            "supports IPv6 on iOS?",
            "SomeThing w1th, apo'strophe's and' punc]tuation",
            "nothing special",
            "5pecial ca5e",
            "1337",
            "1337-spEAk",
            "abcD",
            "a",
            "B")
    testCases.forEach { println(a(it)) }

}

Scala中，181 170 144

def f(s:String)={val l=s.replaceAll("'|`","")split("[\\W_]+|(?<=[a-z])(?=[A-Z][a-z])")map(_.toLowerCase);l(0)+l.tail.map(_.capitalize).mkString}

测试人员：

val testCases = List(
  "Programming Puzzles & Code Golf" -> "programmingPuzzlesCodeGolf",
  "XML HTTP request" -> "xmlHttpRequest"
  // etc
)
println(testCases.map(t=>if(t._2!=f(t._1))s"FAIL:${f(t._1)}"else"PASS").mkString("\n"))

对CAD97的支持和对Nathan Merrill的歉意:)

C 272个字符

C程序将引号中的字符串传递给camelCase作为参数1。在此问题陈述中有很多陷阱...

#define S strlen(t)
#define A isalnum(t[i])
j=0;main(i,v)char**v;{char*p=v[1],*t;char o[99]={0};while(t=strtok(p," [{(~!@#$%^*-+=)}]")){i=0;p+=S+1;while((!A)&&i<S)i++;if(i!=S){o[j]=((j++==0)?tolower(t[i++]):toupper(t[i++]));while(i<S){if(A)o[j++]=t[i];i++;}}}puts(o);}

JavaScript，123个字节

v=>v[r="replace"](/[`']/g,"")[r](/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())[r](/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

可读版本

v=>
  v.replace(/[`']/g,"")
  .replace(/^.|.$|[A-Z][^a-z]+/g,x=>x.toLowerCase())
  .replace(/[^a-z0-9]+./ig,x=>x.slice(-1).toUpperCase())

删除撇号，使第一个字符小写，最后一个字符小写，以及多个大写字符的任何分组，匹配1个或多个非字母数字字符+ 1个其他字符的任何组，并用最后一个大写字母替换。

Mrw247解决方案中的[r =“ replace”]技巧。