Todo el mundo sabe que los gatos maullan, pero lo que muchos no se dan cuenta es que los caaaats se van muuuuuuuy. De hecho, la longitud de los sonidos de las vocales que hace el gato depende de la longitud de la vocal con la que la abordes.

De la misma manera, las vacas se mudan, pero las muuuchas se muuuuu

Reto

Debe escribir un programa que tome como entrada, una palabra que significa gato y una palabra que significa vaca, determine el número de vocales principales e imprima una de las siguientes cadenas, según corresponda:

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

Donde se []encuentran las vocales, de acuerdo con las siguientes reglas:

• El número de e's y o's en "Miau" debe coincidir con el número de vocales encontradas en la palabra de entrada.
• El número de o en "Moo" debe ser el doble del número de vocales encontradas en la palabra de entrada.

El programa debe reconocer las palabras de entrada caty cow. La entrada puede usar cualquier uso de mayúsculas que sea más conveniente, pero la salida debe estar en mayúscula exactamente como se muestra arriba.

Retina , 57 49 44 43 41 bytes

Tan cerca... :) Pyth ...

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

Pruébalo en línea.

Espera que la entrada se capitalice como Caaato Coooow.

Explicación

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

La expresión regular coincide con toda la entrada y captura las vocales en grupo 1(no necesitamos anclajes, porque la coincidencia no puede fallar y codiciosamente coincidirá con toda la entrada). La sustitución reescribe esa entrada y agrega s go M, seguida del doble de las vocales. Para entradas CaaatyCoooow , obtenemos:

Caaats go Maaaaaa
Coooows go Moooooooo

El resultado para las vacas ya es correcto. Solo necesitamos hacer algo con esos gatos.

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

El +le dice a Retina que repita esta etapa tan a menudo como sea posible. La expresión regular coincide con dos as en la última parte de la cadena (nos aseguramos de esto con el $ancla, para que no reemplacemos las cosas dentro Caaats). Esto esencialmente coincidirá con todo después M, siempre y cuando esa parte todavía tenga as. Los dos as se eliminan y todo el sufijo después de envolverse en e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Finalmente, hay dos muchos ws en el resultado, por lo que eliminamos los que preceden a un o(para asegurarnos de que no estamos estropeando el win Coooows):

wo
o

Y nos quedamos con:

Caaats go Meeeooow

LabVIEW, 58 primitivas de LabVIEW

crear cadenas como esta es un dolor ...

Las vis más a la izquierda son patrones coincidentes, a + y o + respectivamente buscan la mayor cantidad de as y os en una fila.

Tomando la longitud de aquellos, creo 3 matrices 1 con longitud os 1 con longitudes y una con 2 veces longitud os.

Entonces todas las partes se juntan. Primero la entrada original, luego s M M todas las matrices, las no utilizadas están vacías, por lo que serán ignoradas, y finalmente aw si la entrada fue gatos. (Si como se encontró, habrá después de la coincidencia, si no después de que la coincidencia esté vacía)

Para el lolz también implementé el zorro con 6 salidas diferentes ^^

Pyth, 50 44 34

Toma entrada en el formato ["caat", "coow"].

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

Pruébalo en línea.

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"

Gracias a Jakube por las grandes reducciones de longitud.

Perl, 66 61 55 54 bytes

incluye +1 para -p

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

Se espera que la entrada se ajuste a /^C[ao]+[tw]$/(¡sin nueva línea final!)
Uso:/bin/echo -n Caaat | perl -p 55.pl

Descompostura

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

Versión previa:

@l=/[ao]/g;$x=$&[email protected] 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.

Ejemplo: Caaat

• Capturar $&como ay @lcomo(a,a,a) .
• Establecer $xen tres veces aseguido de 3 veces o:aaaooo .
• Traducir todo aen $xa e: eeeooo. El número de reemplazos (ya sea 0 o positivo) sirve como un detector de gatos: establecido $yenw ser así.
• Cambie la entrada agregando s go M, eeeoooy w.

• actualización 61 : ahorre 5 bytes utilizando la lista en lugar de la cadena
• Actualización 55 : guarde 6 bytes haciendo inline, asignando en $\lugar des/$/ y no requiriendo nueva línea final en la entrada.
• Actualización 54 : ahorre 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']

Toma entrada

Caaat o Cooow

CJam ( 60 57 55 53 bytes)

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

Demo en línea . Se supone que la entrada está en minúsculas.

Para la misma longitud:

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

_{(los saltos de línea cuentan lo mismo que los puntos y comas, por lo que se rompe la línea para mayor claridad)}

Sorprendentemente difícil desafío. Y estoy razonablemente seguro de que esto se puede jugar más.

Toma cadenas de entrada como $ay $b. Los concatena y los arroja como una matriz de caracteres, luego los canaliza a través de un bucle %{}. A continuación, se verifica si cada letra es -equal 'a'y la variable de contador asociada se incrementa adecuadamente. Entonces restamos 4+$cde $ddar cuenta de catcwen la entrada, y procede a formular las sentencias de salida, la modificación de los tiempos de salida de los contadores de las vocales correspondientes. (En PowerShell, 'e'*3produciría 'eee', por ejemplo).

Casi similar a la respuesta de @ omulusnr, pero esto produce la salida correcta y también la entrada no distingue entre mayúsculas y 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" :""))}

Sin golf:

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

Toma gato o vaca cualquier capitalización. Puedes probarlo aquí:

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

Sin golf:

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

Pruebas:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PD: ¡Gracias a @Kenney por su buena sugerencia (ver comentarios)!

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

legible:

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

intentado más corto pero no funcionará en 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

Primera versión con variables y explicación, 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}]);

Explicación: L sabe qué animal contiene qué letra. S sabe lo que repiten. Sabemos el final. Necesitas tener activada la "transmisión automática" para que esto funcione, pero debería estar por defecto en todas las octavas que he usado. Por supuesto, existen formas más cortas con, por ejemplo, el comando regexprep (expresiones regulares con reemplazo), pero ya ha habido varios enfoques de este tipo en las respuestas, por lo que sería aburrido.

Editar: omitiendo variables que solo ocurren una vez, usando una indexación de octava sobre la marcha (no sé cómo se llama real) y agregando "i", variable de cadena 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':''))

Pruébelo aquí: 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"))

Toma entradas como 'Caats' o 'Coooows' distingue entre mayúsculas y minúsculas. Como no hay requisitos para entradas no válidas, la salida puede ser extraña para, por ejemplo, 'zorros' u 'bueyes'. :PAGS

Sin golf

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

Actualización a 90 bytes: se reemplazó la estructura de control de if con operadores lógicos, se optimizó la concatenación de cadenas al agregar más datos en la declaración de i. Se eliminó el paréntesis en i:find("w"). Curiosamente, el almacenamiento "o"en una variable ahorró un par de bytes cuando se usa rep, pero sería contraproducente con "w"o "e". Cuanto más sepas.

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

toma C[]to C[]wcomo entrada; [] = a's u o's. Una entrada en minúsculas se traducirá en el resultado.

Versión larga:

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

Salidas de ejemplo:

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

Editar: cambiado if then elsea and or. eliminó TODOS los espacios sin cadenas.

También puedes probarlo aquí: Ejecuta Lua Online, pero no pude descubrir cómo usar el terminal, así que lo puse en una función.

Editar: se modificó el uso de "o" y se eliminó () de :find. el crédito va a Cyv por encontrar esas optimizaciones. Se agregó "s" y se cambió l=#i-3al=#i-2

Con entrada que incluye "s" solo 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))

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

Pruébalo en línea!

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 cualquier capitalización alguna. CaAaT, coOOOwlo que sea.

v2: realmente no necesito [wt] $. también corrigió char ct
v3: char ct estaba todo mal, condensó $ a y $ e asignación
v4: guarde 3 bytes en $ af -> $ a
v5: guarde 4 bytes alineándolo (no se muestra)