人人都知道猫咪会喵喵叫，但许多人没有意识到的是猫咪会喵喵叫。实际上，猫发出的元音声音的长度取决于您用来寻址的元音的长度。

以同样的方式，母牛变得go咕，但是母牛却咕mo咕o

挑战

您将编写一个程序，该程序将一个单词（表示猫）和一个单词（表示牛）作为输入，确定主元音的数量，并根据需要打印以下字符串之一：

• C[]ts go M[]w
• C[]ws go M[]

[]元音在哪里代表，请遵循以下规则：

• “喵”中的e和o的数量必须都与输入单词中找到的元音的数量相同。
• “ Moo”中o的数量必须是输入单词中元音数量的两倍。

程序必须识别输入的单词cat和cow。输入可以使用最方便的任何大写形式，但是输出必须完全如上所示大写。

视网膜，57 49 44 43 41字节

太近了... :) Pyth ...

.(.+).
$0s go M$1$1
+`aa(\w*$)
e$1ow
wo
o

在线尝试。

期望输入像Caaat或大写Coooow。

说明

.(.+).
$0s go M$1$1

正则表达式匹配整个输入，并捕获组中的元音1（我们不需要锚，因为匹配不会失败，并且会贪婪地匹配整个输入）。替换将回写该输入，并追加s go M，后跟两次元音。对于输入Caaat和Coooow，我们得到：

Caaats go Maaaaaa
Coooows go Moooooooo

母牛的输出已经正确。我们只需要对那些猫做些事情。

+`aa(\w*$)
e$1ow

该+告诉视网膜经常重复这个阶段成为可能。正则表达式a在字符串的最后一部分匹配两个s（我们用$锚确保它，因此我们不替换里面的东西Caaats）。M只要该部分仍具有as ，它将基本上匹配之后的所有内容。将两个as删除，并将其后的整个后缀包装在e...ow：

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

最后，结果中有两个很多ws，因此我们删除了s之前的那些o（以确保我们不会弄乱win Coooows）：

wo
o

我们剩下的是：

Caaats go Meeeooow

LabVIEW，58个LabVIEW原语

创建这样的字符串很痛苦...

最左边的vis是模式匹配，a +和o +分别搜索连续的as和os的最大量。

考虑到这些长度，我创建了3个数组，长度为os 1，长度为es，一个数组的长度为2倍。

然后将所有零件放在一起。首先是原始输入，然后是所有数组，所有未使用的都是空的，因此它们将被忽略，如果输入是cat，最后是a。（如果找到的话，在比赛之后将会有at，如果在比赛之后没有则为空）

对于lolz，我还用6种不同的输出实现了狐狸^^

Pyth，50 44 34

接受格式为的输入["caat", "coow"]。

Pj.bs[rN3"s go M"S*-lN2+Y\o\w)Q"eo

在线尝试。

解释：

  .b                                  Map a lambda across two lists in parallel:
                              Q       The input, e.g. ["caat", "coow"]
                               "eo    The string "eo"
    s[                       )            Create and concatenate a list of:
      rN3                                 - The item N in title caps (e.g. "Caat")
         "s go M"                         - The string "s go M"
                 S                        - The sorted version of:
                       +Y\o                   The item Y + "o" ("eo" or "oo")
                  *-lN2                       Times the length of N - 2 (number of vowels)
                           \w             - The string "w"
Pj                                    Join the result on \n and drop the final "w"

感谢Jakube大大减少了长度。

Perl，66 61 55 54字节

为包括+1 -p

/[ao]+/;$\="s go M".$&=~y/a/e/r.o x($+[0]-1).(w)[/w/]

预期输入符合/^C[ao]+[tw]$/（没有尾随换行符！）
用法：/bin/echo -n Caaat | perl -p 55.pl

分解

/[ao]+/;
$\= "s go M"        # assign to $OUTPUT_RECORD_SEPARATOR, normally `\n`. Saves 1 vs `$_.=`
   . $&             # the matched vowels
     =~ y/a/e/r     # translate `a` to `e`; `/r` returns a copy.
   . o x($+[0]-1)   # append 'o', repeated. $+[0] is string position of last match end.
   . (w)[/w/]       # returns 'w' if there is no /w/ in the input, nothing if there is.

先前版本：

@l=/[ao]/g;$x=$&x@l.o x@l;$y=$x=~y/a/e/?w:'';s/$/s go M$x$y/

评论：

@l = /[ao]/g;               # captures $& as vowel and @l as list of vowels
$x = $& x @l .o x @l;       # construct the output vowels
$y = $x =~ y/a/e/ ? w : ''; # correct vowel string for cats (aaaooo->eeeooo); $y='w' if cat.
s/$/s go M$x$y/             # construct the desired output.

例： Caaat

• 捕捉$&作为a和@l作为(a,a,a)。
• 设置$x为3次a然后是3次o：aaaooo。
• 翻译所有a的$x到e：eeeooo。替换数（0或正数）用作猫检测器：如果设置$y，w则设置为。
• 通过附加改变输入s go M，eeeooo以及w。

• 更新61：通过使用列表而不是字符串节省5个字节
• 更新55：通过内联，分配$\而不是s/$/，并且在输入中不需要尾随换行符来节省6个字节。
• 更新54：通过消除@l节省1个字节。

Python 2，74个字节

i=input()
l=len(i)-2
print i+'s go M'+['e'*l+'o'*l+'w','o'*l*2][i[-1]>'v']

接受输入

Caaat 要么 Cooow

CJam（60 57 55 53字节）

"C%s%ss go M%sw
"2*-2<q"ctw"-S/"teowoo"3/.{(2$,@*$}e%

在线演示。假定输入为小写。

对于相同的长度：

"C

s go M"N/_]"w
"a*q"ctw"-S/"teowoo"3/.{(2$,@*$M}]z

'CM"s go M"]2*q"ctw"-S/"teowoo"3/.{(2$,@*$}[MM"w
"]]z

PowerShell中，135个 132字节

param($a,$b)
[char[]]"$a$b"|%{if($_-eq'a'){$c++}$d++}
$d-=4+$c
"C$("a"*$c)ts go M$("e"*$c)$("o"*$c)w"
"C$("o"*$d)ws go M$("o"*2*$d)"

_{（换行符与分号相同，因此为清晰起见，换行符）}

令人惊讶的棘手挑战。而且我有合理的把握，可以继续打下去。

将输入字符串作为$a和$b。连接它们并将其转换为char数组，然后将其通过循环传递%{}。然后，检查每个字母是否与该字母-eq成对，'a'并且相应的计数器变量适当增加。然后4+$c，我们从中减去$d以解释catcw输入，并继续制定输出语句，将元音输出乘以相应的计数器。（例如，在PowerShell中，'e'*3将产生'eee'。）

几乎类似于@omulusnr的答案，但这会生成正确的输出，并且输入也不区分大小写。

PHP 172

$p=$argv[1];
preg_match("/c([ao]+)/i",$p,$e);
$l=strlen($e[1]);
$s=($k=strcmp($e[0][1],'o'))?'eo':'oo';
echo $p,' go M',str_repeat($s[0],$l),str_repeat($s[1],$l),$k?'w':'';

斯威夫特2、3̶8̶1̶ 333字节

func f(i:String)->String{var s=i.lowercaseString;s.replaceRange(s.startIndex...s.startIndex,with:String(s[s.startIndex]).uppercaseString);let c=i.characters.count-2;let l=s.characters.last;return(s+"s go M"+String(count:c,repeatedValue:l=="t" ?"e" :"o" as Character)+String(count:c,repeatedValue:"o" as Character)+(l=="t" ?"w" :""))}

取消高尔夫：

func f(i:String)->String{
    var s = i.lowercaseString
    s.replaceRange(s.startIndex...s.startIndex,with:String(s[s.startIndex]).uppercaseString)
    let c = i.characters.count-2
    let l = s.characters.last
    return(s+"s go M"+String(count:c,repeatedValue:l=="t" ?"e" :"o" as Character)+String(count:c,repeatedValue:"o" as Character)+(l=="t" ?"w" :""))
}

将猫或牛大写。您可以在这里尝试：

http://swiftlang.ng.bluemix.net/#/repl/3f79a5335cb745bf0ba7698804ae5da166dcee6663f1de4b045e3b8fa7e48415

MATLAB：190个 152 118字节

i=input('','s');b=sum(i=='a');c=sum(i=='o');d=b>c;disp(['C',i(2:2+b+c),'s go M',i(2:1+b)+4,repmat('o',1,b+2*c),'w'*d])

取消高尔夫：

i=input('','s');
b=sum(i=='a');
c=sum(i=='o');
d=b>c;
disp(['C',i(2:2+b+c),'s go M',i(2:1+b)+4,repmat('o',1,b+2*c),'w'*d])

测试：

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PS：感谢@Kenney的好建议（请参阅评论）！

PHP，138字节

echo ucfirst($a=$argv[1]).'s go M'.(($n=substr_count($a,'a'))?str_repeat('e',$n).str_repeat('o',$n).'w':str_repeat('oo',substr_count($a,'o')));

可读性：

echo ucfirst($a = $argv[1]) . 's go M'. (
    ($n = substr_count($a, 'a'))
        ? str_repeat('e', $n) . str_repeat('o', $n) . 'w'
        : str_repeat('oo', substr_count($a, 'o'))
);

尝试了更短但在PHP中无法正常工作：

#too long -- echo ucfirst($s=$argv[1]).'s go M'.(($o='o'and$n=substr_count($s,'a'))?str_repeat('e',$n).str_repeat($o,$n).'w':str_repeat('oo',substr_count($s,$o)));
#too long -- echo ucfirst($s=$argv[1]).'s go M'.(($o='o'and$f=function($s,$n){return str_repeat($s,$n);}and$n=substr_count($s,'a'))?$f('e',$n).$f($o,$n).'w':$f('oo',substr_count($s,$o)));

=）

OCTAVE，126，108

带有变量和解释的第一版，126：

L="ao"';S={'eo','oo'},e={'w',' '};a=sum(argv(){1}==L,2);b=find(a);disp([argv(){1},' goes m',vec(ones(sum(a),1)*S{b})',e{b}]);

说明：L知道哪个动物包含哪个字母。S知道他们重复什么。e知道结局。您需要打开“自动广播”才能使它起作用，但是默认情况下，在我使用过的所有八度音程中，它都应该是默认的。当然，例如使用命令regexprep（带替换的正则表达式）存在更短的方法，但是答案中已经有几种这样的方法，这将很无聊。

编辑：跳过仅发生一次的变量，使用八度即时索引（不知道它叫什么真正的），并添加“ i”，输入字符串变量：

i=argv(){1};a=sum(i=="ao"',2);b=find(a);disp([i,' goes m',vec(ones(sum(a),1)*{'eo','oo'}{b})',{'w',''}{b}]);

JavaScript（ES2015）， 78 77

s=>s+'s go M'+(l=s.length-1,w=s[l]<'u',Array(l).join(w?'eo':'oo')+(w?'w':''))

在这里尝试：https : //jsbin.com/guqaxejiha/1/edit?js,console

Lua，121个 90字节

121字节

i=...r="M"o="o"s=i:len()-3if(i:find("w"))then r=r..o:rep(s*2)else r=r..("e"):rep(s)..o:rep(s).."w"end print(i.." go "..r)

90字节

i=....." go M"o="o"s=#i-7 print(i..(i:find"w"and o:rep(s*2)or("e"):rep(s)..o:rep(s).."w"))

输入区分大小写的“ Caats”或“ Coooows”之类的输入。由于没有无效输入的要求，因此对于“ Foxes”或“ Oxen”来说，输出可能会很奇怪。：P

不打高尔夫球

i=... .. " go M"
o="o"
s=#i-7
print(i..
         (i:find"w"and o:rep(s*2) or 
         ("e"):rep(s)..o:rep(s).."w")
      )

更新到90个字节：用逻辑运算符替换了if-control结构，通过在的声明中附加更多数据来优化字符串连接i。删除了上的括号i:find("w")。有趣的是，"o"使用时rep，将变量存储到变量可以节省几个字节，但使用"w"或将适得其反"e"。你懂得越多。

Lua：115 92 89字节

i=...l=#i-2o="o"io.write(i,"s go M",i:find"a"and("e"):rep(l)..o:rep(l).."w"or o:rep(l*2))

以C[]t或C[]w作为输入; [] = a或o。小写输入将转换为结果。

长版：

i=...   --"C[]t" or "C[]w"
l=#i-2  --length of input -2
o="o"   --shorten usage of "o"
io.write(i,"s go M",i:find"a"and("e"):rep(l)..o:rep(l).."w"or o:rep(l*2)) 

-- if it's a C"a"t concat "s go M" then repeat  --> Cats/Cows go M
-- "e" and then "o" l times and concat else     --> Cats go Meo
-- repeat "o" l*2 times and concat              --> Cows go Moo
-- concat "w" and output evrything              --> Cats go Meow

输出示例：

Caaat --> Caaats go Meeeooow
Cat   --> Cats go Meow
Cow   --> Cows go Moo

编辑：更改if then else为and or。删除了所有非字符串空间。

您也可以在这里尝试一下：在线执行Lua，但是我不知道如何使用终端，因此将其放入函数中。

编辑：更改了“ o”的用法，并从中删除了（）:find。归功于Cyv寻找这些优化。添加了“ s”并更改l=#i-3为l=#i-2

输入仅包含“ s”的88个字节：

i=...l=#i-3o="o"io.write(i," go M",i:find"a"and("e"):rep(l)..o:rep(l).."w"or o:rep(l*2))

镖，114个112 110 104 102 100字节

f(s)=>s+'s go M'.padRight(s[1]=='a'?s.length+4:0,'e').padRight(2*s.length+2,'o')+(s[1]=='a'?'w':'');

在线尝试！

PHP，170个 164 161 157字节

preg_match("/(?i)c([ao]+)/",$argv[1],$e);
$n=strlen($e[1]);
$c=$e[1][0];
$a=($c=="a"?("ew"):("o"));
echo "M".str_repeat($a[0],$n).str_repeat("o",$n).$a[1]."\n";

采取任何大写形式。CaAaT，coOOOw，等等。

v2：确实不需要[wt] $。还更正了char ct
v3：char ct都错了，压缩了$ a和$ e赋值
v4：在$ af- > $ a
v5上保存3个字节：对它加一行以保存4个字节（未显示）