Tout le monde sait que les chats vont miaou, mais ce que beaucoup ne réalisent pas, c'est que les caaaats vont meeeeoooow. En fait, la longueur de la voyelle émise par le chat dépend de la longueur de la voyelle avec laquelle vous l'adressez.

De la même manière, les vaches vont à meuh, mais les coooows vont à meuh

Défi

Vous devez écrire un programme qui prend en entrée un mot signifiant chat et un mot signifiant vache, détermine le nombre de voyelles principales et affiche l'une des chaînes suivantes, selon le cas:

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

Où []signifie les voyelles, selon les règles suivantes:

• Le nombre d'e et d'u dans "Meow" doit correspondre au nombre de voyelles trouvées dans le mot d'entrée.
• Le nombre de o dans "Moo" doit être le double du nombre de voyelles trouvées dans le mot saisi.

Le programme doit reconnaître les mots d'entrée catet cow. Les entrées peuvent utiliser n'importe quelle capitalisation qui convient le mieux, mais la sortie doit être mise en majuscule exactement comme indiqué ci-dessus.

Retina , 57 49 44 43 41 octets

Si proche ... :) Pyth ...

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

Essayez-le en ligne.

Les entrées devraient être capitalisées comme Caaatou Coooow.

Explication

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

La regex correspond à la totalité de l'entrée et capture les voyelles dans un groupe 1(nous n'avons pas besoin d'ancres, car la correspondance ne peut pas échouer et correspondra avec enthousiasme à la totalité de l'entrée). La substitution réécrit cette entrée et l'ajoute s go M, suivie de deux fois les voyelles. Pour les entrées Caaatet Coooow, on obtient:

Caaats go Maaaaaa
Coooows go Moooooooo

La sortie pour les vaches est déjà correcte. Nous devons juste faire quelque chose à propos de ces chats.

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

Le +dit à la rétine de répéter cette étape aussi souvent que possible. La regex correspond à deux asecondes dans la dernière partie de la chaîne (nous l’assurons avec l’ $ancre pour ne pas remplacer des éléments à l’intérieur Caaats). Cela correspondra essentiellement à tout après M, tant que cette partie a encore as. Les deux as sont supprimés et le suffixe entier après qu'il soit enveloppé dans e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Enfin, il y a deux nombreux ws dans le résultat, donc nous retirons ceux qui précèdent un o(pour nous assurer que nous ne sommes pas déconner le wdans Coooows):

wo
o

Et nous nous retrouvons avec:

Caaats go Meeeooow

LabVIEW, 58 primitives LabVIEW

créer des cordes comme celle-là est une douleur ...

Les vis les plus à gauche correspondent à un motif, a + et o + recherchent respectivement la dernière quantité de as et os dans une rangée.

En prenant la longueur de ceux-ci, je crée 3 tableaux 1 avec la longueur os 1 avec la longueur es et un avec 2 fois la longueur os.

Ensuite, toutes les pièces sont assemblées. Tout d’abord, l’entrée initiale, puis tous les tableaux, les inutilisés sont vides, ils seront donc ignorés, et enfin aw si l’entrée était des chats. (Si comme trouvé, il y aura à la fin du match, sinon après le match est vide)

Pour le lolz j’ai aussi implémenté le renard avec 6 sorties différentes ^^

Pyth, 50 44 34

Prend l'entrée dans le format ["caat", "coow"].

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

Essayez-le en ligne.

A expliqué:

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

Merci à Jakube pour les réductions de longueur importantes.

Perl, 66 61 55 54 octets

comprend +1 pour -p

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

L'entrée est censée se conformer à /^C[ao]+[tw]$/(pas de nouvelle ligne!)
./bin/echo -n Caaat | perl -p 55.pl

Panne

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

La version précédente:

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

Commenté :

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

Exemple: Caaat

• Capturer $& fur aet à @lmesure (a,a,a).
• Ensemble $x trois fois asuivi par 3 fois o: aaaooo.
• Tout traduire aen$x à e: eeeooo. Le nombre de remplacements (0 ou positif) sert de détecteur de chat: défini $ysur wsi.
• Modifier l'entrée en ajoutant s go M,eeeooo et w.

• update 61 : Sauvegarde 5 octets en utilisant list au lieu de string
• mise à jour 55 : sauvegarde de 6 octets en alignant, assignant $\plutôt que s/$/, et ne nécessitant aucune nouvelle ligne en fin de saisie.
• mise à jour 54 : économisez 1 octet en éliminant @l.

Python 2, 74 octets

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

Prend des entrées

Caaat ou Cooow

CJam ( 60 57 55 53 octets)

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

Démo en ligne . L'entrée est supposée être en minuscule.

Pour la même longueur:

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

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

_{(les sauts de ligne comptent comme des points-virgules, donc les sauts de ligne sont plus clairs)}

Défi étonnamment délicat. Et je suis raisonnablement sûr que cela peut être joué plus loin.

Prend des chaînes d’entrée au fur $aet à mesure $b. Les concatène et les jette comme un tableau de caractères, puis les dirige à travers une boucle %{}. Chaque lettre est ensuite vérifié si elle est -equel à 'a'et la variable de compteur associé est incrémenté de manière appropriée. Nous soustrayons ensuite 4+$cde $dpour rendre compte catcwdans l’entrée, puis procédons à la formulation des phrases en sortie, en modifiant les voyelles à la sortie multipliées par les compteurs correspondants. (Dans PowerShell, vous 'e'*3obtiendrez 'eee', par exemple.)

Presque similaire à la réponse de @ omulusnr mais ceci produit la sortie correcte et l'entrée est également sensible à la casse.

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 octets

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

Prend chat ou vache n'importe quelle capitalisation. Vous pouvez l'essayer ici:

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

MATLAB: 190 152 118 octets

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

Tests:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PS: Merci à @Kenney pour la suggestion intéressante (voir les commentaires)!

PHP, 138 octets

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

lisible:

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

essayé plus court mais ne fonctionnera pas 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

Première version avec variables et explication, 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}]);

Explication: L sait quel animal contient quelle lettre. S sait ce qu'ils répètent. e connaît la fin. La "diffusion automatique" doit être activée pour que cela fonctionne, mais cela devrait être par défaut dans toutes les Octaves que j'ai utilisées. Bien sûr, il existe des méthodes plus courtes avec, par exemple, la commande regexprep (expressions rationnelles avec remplacement), mais il existe déjà plusieurs approches de ce type dans les réponses, ce qui serait donc ennuyeux.

Éditer: Ignorer les variables qui ne se produisent qu’une seule fois, en utilisant l’indexation octave à la volée (je ne sais pas ce qu’on appelle réellement) et en ajoutant "i", variable de chaîne de saisie:

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

Essayez-le ici: https://jsbin.com/guqaxejiha/1/edit?js,console

Lua, 121 90 octets

121 octets

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 octets

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

Prend des entrées telles que 'Caats' ou 'Coooows' en respectant la casse. Etant donné qu'il n'y a pas d'exigences pour des entrées non valides, la sortie peut être bizarre pour, par exemple, 'Foxes' ou 'Oxen'. : 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")
      )

Mise à jour à 90 octets: structure if-control remplacée par des opérateurs logiques, optimisation de la concaténation de chaînes en ajoutant davantage de données dans la déclaration de i. Suppression de parenthèses sur i:find("w"). Il est intéressant de noter que le stockage "o"dans une variable économisait quelques octets lors de l’utilisation rep, mais serait contre-productif avec "w"ou "e". Plus vous en savez.

Lua: 115 92 89 octets

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

prend C[]touC[]w en entrée; [] = a ou o. Une entrée de casse basse se traduira par le résultat.

version longue:

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

Exemple de sorties:

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

Modifier: remplacé if then elseparand or . supprimé TOUS les espaces non-chaînes.

Vous aussi, essayez-le ici: Exécutez Lua Online mais je ne savais pas comment utiliser le terminal, je l'ai donc mis dans une fonction.

Edit: modification de l'utilisation de "o" et enlevé () de :find. le crédit revient à Cyv pour avoir trouvé ces optimisations. Ajouté "s" et remplacé l=#i-3parl=#i-2

Avec une entrée comprenant "s" seulement 88 octets:

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 octets

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

Essayez-le en ligne!

PHP, 170 164 161 157 octets

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

Prend n'importe quelle capitalisation que ce soit. CaAaT, peu coOOOwimporte.

v2: n'a pas vraiment besoin de [wt] $. corrigé également car ct
v3: car ct était tout à fait faux, condensé $ a et $ e affectation
v4: économisez 3 octets sur $ af -> $ a
v5: économisez 4 octets en le sélectionnant (non affiché)