Todo mundo sabe que os gatos ficam miau, mas o que muitos não percebem é que os caaaats ficam meeeeoooow. De fato, o comprimento da vogal que o gato produz depende do comprimento da vogal com a qual você a dirige.

Da mesma forma, vacas vão moo, mas coooows vão moooooooo

Desafio

Você deve escrever um programa que use como entrada, uma palavra que significa gato e uma palavra que signifique vaca, determine o número de vogais principais e imprima uma das seguintes seqüências de caracteres, conforme apropriado:

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

Onde []significa as vogais, de acordo com as seguintes regras:

• O número de e e o em "Miau" deve coincidir com o número de vogais encontradas na palavra de entrada.
• O número de o's em "Moo" deve ser o dobro do número de vogais encontradas na palavra de entrada.

O programa deve reconhecer as palavras de entrada cate cow. A entrada pode usar qualquer capitalização mais conveniente, mas a saída deve ser capitalizada exatamente como mostrado acima.

Retina , 57 49 44 43 41 bytes

Tão perto ... :) Pitão ...

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

Experimente online.

Espera que a entrada seja capitalizada como Caaatou Coooow.

Explicação

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

A regex corresponde à entrada inteira e captura as vogais no grupo 1(não precisamos de âncoras, porque a correspondência não pode falhar e corresponderá avidamente à entrada inteira). As gravações de substituição de trás que a entrada, e anexa s go M, seguido por duas vezes as vogais. Para entradas Caaate Coooow, obtemos:

Caaats go Maaaaaa
Coooows go Moooooooo

A saída para vacas já está correta. Nós só precisamos fazer algo sobre esses gatos.

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

O +diz à Retina para repetir esta etapa o mais rápido possível. O regex corresponde a dois as na última parte da string (garantimos isso com a $âncora, para não substituir as coisas por dentro Caaats). Isso corresponderá essencialmente a tudo depois M, desde que essa parte ainda tenha as. Os dois as são removidos e o sufixo inteiro depois de envolver e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Finalmente, existem dois muitos ws no resultado, portanto, removemos aqueles que precedem um o(para garantir que não estamos atrapalhando o win Coooows):

wo
o

E ficamos com:

Caaats go Meeeooow

LabVIEW, 58 Primitivas do LabVIEW

criar cordas como essa é uma dor ...

O vis mais à esquerda é a correspondência de padrões, a + e o + pesquisam, respectivamente, a quantidade mais atrasada de as e os em uma linha.

Tomando o comprimento desses, crio 3 matrizes 1 com comprimento os 1 com comprimento es e uma com 2 vezes o comprimento.

Então todas as peças são reunidas. Primeiro a entrada original, depois M todas as matrizes, a não utilizada fica vazia para que sejam ignoradas e, finalmente, se a entrada for de gato. (Se como foi encontrado, haverá após a partida, se não depois da partida estiver vazia)

Para o lolz eu também implementei o fox com 6 saídas diferentes ^^

Pitão, 50 44 34

Recebe entrada no formato ["caat", "coow"].

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

Experimente online.

Explicado:

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

Obrigado a Jakube pelas grandes reduções de comprimento.

Perl, 66 61 55 54 bytes

inclui +1 para -p

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

A entrada é esperado para estar de acordo com /^C[ao]+[tw]$/(sem mudança de linha à direita!)
Uso:/bin/echo -n Caaat | perl -p 55.pl

Demolir

/[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.

Versão anterior:

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

Comentado :

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

Exemplo: Caaat

• Capturar $&como ae @lcomo (a,a,a).
• Definir $xa três vezes a, seguido de 3 vezes o: aaaooo.
• Traduzir tudo aem $xque e: eeeooo. O número de substituições (0 ou positivo) serve como um detector de gato: defina $ycomo wsim.
• Mude a entrada acrescentando s go M, eeeoooe w.

• atualização 61 : economize 5 bytes usando list em vez de string
• actualizar 55 : desc 6 bytes por inlining, a atribuição de $\, em vez de s/$/, e não necessitando de final de linha de entrada.
• atualização 54 : economize 1 byte eliminando @l.

Python 2, 74 bytes

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

Recebe entrada

Caaat ou Cooow

CJam ( 60 57 55 53 bytes)

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

Demonstração online . A entrada é assumida como minúscula.

Para o mesmo comprimento:

"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 bytes

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)"

_{(as quebras de linha contam o mesmo que ponto e vírgula, portanto, são quebradas para maior clareza)}

Desafio surpreendentemente complicado. E estou razoavelmente certo de que isso pode ser ainda mais importante.

Toma seqüências de entrada como $ae $b. Concatena-os e os projeta como um conjunto de caracteres, e depois passa por um loop %{}. Cada letra é então verificada se é o -equal 'a'e a variável de contador associada é incrementada adequadamente. Em seguida, subtraímos 4+$cde $dpara contabilizar catcwna entrada e procedemos à formulação das sentenças de saída, modificando os tempos de saída das vogais nos contadores correspondentes. (No PowerShell, 'e'*3renderia 'eee', por exemplo.)

Quase semelhante à resposta do @ omulusnr, mas isso produz a saída correta e também a entrada não diferencia maiúsculas de minúsculas.

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':'';

Swift 2, 3̶8̶1̶ 333 bytes

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" :""))}

Ungolfed:

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" :""))
}

Leva gato ou vaca qualquer capitalização. Você pode tentar aqui:

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

MATLAB: 190 152 118 bytes

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])

Ungolfed:

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])

Testes:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PS: Obrigado a @Kenney pela boa sugestão (ver comentários)!

PHP, 138 bytes

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')));

legível:

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'))
);

tentou mais curto, mas não vai funcionar em 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

Primeira versão com variáveis ​​e explicação, 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}]);

Explicação: L sabe qual animal contém qual letra. S sabe o que eles repetem. e conhece o final. Você precisa ter a "transmissão automática" ativada para que isso funcione, mas deve estar por padrão em todas as oitavas que usei. É claro que existem maneiras mais curtas com, por exemplo, o comando regexprep (expressões regulares com substituição), mas já existem várias dessas abordagens nas respostas, o que seria chato.

Edit: Ignorando variáveis ​​que ocorrem apenas uma vez, usando a indexação on-the-fly de oitavas (não sei o que é chamado de real) e adicionando "i", variável de string de entrada:

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':''))

Experimente aqui: https://jsbin.com/guqaxejiha/1/edit?js,console

Lua, 121 90 Bytes

121 bytes

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 bytes

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"))

Recebe entradas como 'Caats' ou 'Coooows' que diferenciam maiúsculas de minúsculas. Como não há requisitos para entradas inválidas, a saída pode ser estranha para, por exemplo, 'Foxes' ou 'Bois'. : P

Ungolfed

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")
      )

Atualização para 90 bytes: estrutura if-control substituída por operadores lógicos, concatenação otimizada de cadeias, acrescentando mais dados na declaração de i. Parêntese removido em i:find("w"). Curiosamente, o armazenamento "o"em uma variável economizou alguns bytes ao usar rep, mas seria contraproducente com "w"ou "e". Quanto mais você sabe.

Lua: 115 92 89 Bytes

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

aceita C[]tou C[]wcomo entrada; [] = a ou o. Uma entrada lowecase será traduzida para o resultado.

versão longa:

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

Exemplo de saídas:

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

Editar: alterado if then elsepara and or. removeu TODOS os espaços sem cadeia de caracteres.

Você também pode tentar aqui: Execute Lua Online, mas eu não consegui descobrir como usar o terminal, então coloquei-o em uma função.

Editar: uso alterado de "o" e removido () de :find. o crédito vai para o Cyv por encontrar essas otimizações. Adicionado "s" e alterado l=#i-3paral=#i-2

Com entrada incluindo "s" apenas 88 bytes:

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

Dardo , 114 112 110 104 102 100 bytes

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':'');

Experimente online!

PHP, 170 164 161 157 bytes

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

Toma qualquer capitalização qualquer. CaAaT, coOOOwseja qual for.

v2: realmente não precisa de [wt] $. também corrigiu char ct
v3: char ct estava tudo errado, condensou a atribuição $ a e $ e
v4: economize 3 bytes em $ af -> $ a
v5: economize 4 bytes, marcando-o (não mostrado)