Tutti sanno che i gatti diventano miagolosi, ma ciò che molti non capiscono è che i caaat si muovono. In effetti, la lunghezza della vocale che il gatto emette dipende dalla lunghezza della vocale con cui la si rivolge.

Allo stesso modo, le mucche vanno muggite, ma i cuccioli vanno muggiti

Sfida

Devi scrivere un programma che accetta come input, una parola che significa gatto e una parola che significa mucca, determinare il numero di vocali principali e stampare una delle seguenti stringhe, come appropriato:

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

Dove []sta per le vocali, secondo le seguenti regole:

• Il numero di e e o in "Meow" deve corrispondere al numero di vocali presenti nella parola di input.
• Il numero di o in "Moo" deve essere il doppio del numero di vocali trovate nella parola di input.

Il programma deve riconoscere le parole di input cate cow. L'input può utilizzare qualsiasi maiuscola più conveniente, ma l'output deve essere capitalizzato esattamente come mostrato sopra.

Retina , 57 49 44 43 41 byte

Così vicino ... :) Pyth ...

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

Provalo online.

Si aspetta che l'input sia capitalizzato come Caaato Coooow.

Spiegazione

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

La regex corrisponde all'intero input e cattura le vocali nel gruppo 1(non abbiamo bisogno di ancore, perché la corrispondenza non può fallire e corrisponderà avidamente all'intero input). La sostituzione riscrive quell'input e aggiunge s go M, seguito da due volte le vocali. Per gli input Caaate Coooowotteniamo:

Caaats go Maaaaaa
Coooows go Moooooooo

L'output per le mucche è già corretto. Dobbiamo solo fare qualcosa per quei gatti.

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

La +dice Retina di ripetere questa fase il più spesso possibile. Il regex corrisponde a due as nell'ultima parte della stringa (lo garantiamo con l' $ancoraggio, in modo da non sostituire le cose all'interno Caaats). Questo essenzialmente corrisponderà a tutto ciò che segue M, purché quella parte abbia ancora as. I due as vengono rimossi e l'intero suffisso dopo che è stato racchiuso e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Infine, ci sono due molti ws nel risultato, quindi rimuoviamo quelli che precedono un o(per assicurarci di non rovinare l' win Coooows):

wo
o

E restiamo con:

Caaats go Meeeooow

LabVIEW, 58 LabVIEW Primitives

creare stringhe come questa è un dolore ...

La vis più a sinistra è il pattern matching, rispettivamente a + e o + cercano la quantità più bassa di as e os in una riga.

Prendendo la lunghezza di quelli che creo 3 matrici 1 con lunghezza os 1 con lunghezza es e una con 2 volte lunghezza os.

Quindi tutte le parti vengono messe insieme. Prima l'input originale, poi vai M tutti gli array, quelli inutilizzati sono vuoti in modo che vengano ignorati e infine aw se l'input fosse gatti. (Se come trovato ci sarà dopo la partita, se non dopo che la partita è vuota)

Per il lolz ho anche implementato la volpe con 6 uscite diverse ^^

Pyth, 50 44 34

Accetta input nel formato ["caat", "coow"].

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

Provalo online.

Ha spiegato:

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

Grazie a Jakube per importanti riduzioni di lunghezza.

Perl, 66 61 55 54 byte

include +1 per -p

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

Ingresso è previsto per conformarsi /^C[ao]+[tw]$/(senza carattere di fine riga!)
Uso:/bin/echo -n Caaat | perl -p 55.pl

Abbattersi

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

Versione precedente:

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

Commentato :

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

Esempio: Caaat

• Cattura $&come ae @lcome (a,a,a).
• Impostare $xa tre volte aseguiti da 3 volte o: aaaooo.
• Tradurre tutto ain $xa e: eeeooo. Il numero di sostituzioni (0 o positivo) funge da rilevatore di cat: impostare $ysu in wtal caso.
• Modificare l'ingresso aggiungendo s go M, eeeoooe w.

• aggiornamento 61 : salva 5 byte utilizzando la lista anziché la stringa
• aggiornamento 55 : salva 6 byte inserendo, assegnando $\piuttosto s/$/che senza richiedere una nuova riga finale nell'input.
• aggiornamento 54 : salva 1 byte eliminando @l.

Python 2, 74 byte

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

Accetta input

Caaat o Cooow

CJam ( 60 57 55 53 byte)

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

Demo online . Si presume che l'input sia in minuscolo.

Per la stessa lunghezza:

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

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

_{(le interruzioni di riga sono uguali ai punti e virgola, quindi vengono interrotte per chiarezza)}

Sfida sorprendentemente complicata. E sono ragionevolmente sicuro che questo possa essere ulteriormente approfondito.

Accetta le stringhe di input come $ae $b. Li concatena e li lancia come un array di caratteri, quindi li convoglia attraverso un anello %{}. Ogni lettera viene controllato se è -eqsessuale al 'a'e la variabile contatore associato viene incrementato in modo appropriato. Quindi sottraggiamo 4+$cda $dper tenere conto catcwdell'input e procediamo a formulare le frasi di output, modificando le vocali di output volte i corrispondenti contatori. (In PowerShell, 'e'*3cederebbe 'eee', ad esempio.)

Quasi simile alla risposta di @ omulusnr ma questo produce l'output corretto e anche l'input non fa distinzione tra maiuscole e minuscole.

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 byte

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

Prende gatto o mucca qualsiasi maiuscola. Puoi provarlo qui:

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

MATLAB: 190 152 118 byte

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

test:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PS: Grazie a @Kenney per il bel suggerimento (vedi commenti)!

PHP, 138 byte

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

leggibile:

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

provato più breve ma non funzionerà in 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)));

=)

OTTAVA, 126 , 108

Prima versione con variabili e spiegazione, 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}]);

Spiegazione: L sa quale animale contiene quale lettera. S sa cosa ripetono. e conosce il finale. Devi aver attivato la "trasmissione automatica" perché funzioni, ma dovrebbe essere di default in tutte le Ottave che ho usato. Naturalmente esistono modi più brevi con ad esempio il comando regexprep (espressioni regolari con sostituzione), ma ci sono già stati diversi approcci simili nelle risposte, quindi sarebbe noioso.

Modifica: salta le variabili che si verificano solo una volta, usando l'indicizzazione al volo dell'ottava (non so come si chiama per davvero) e aggiungendo "i", variabile stringa di input:

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

Provalo qui: https://jsbin.com/guqaxejiha/1/edit?js,console

Lua, 121 90 byte

121 byte

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 byte

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

Accetta input come 'Caats' o 'Coooows' con distinzione tra maiuscole e minuscole. Dato che non ci sono requisiti per input non validi, l'output potrebbe essere strano, per esempio, "Foxes" o "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")
      )

Aggiornamento a 90 byte: sostituita la struttura if-control con operatori logici, concatenazione di stringhe ottimizzata aggiungendo più dati nella dichiarazione di i. Parentesi rimossa attivata i:find("w"). È interessante notare che la memorizzazione "o"in una variabile ha salvato un paio di byte durante l'utilizzo rep, ma sarebbe controproducente con "w"o "e". Più si conosce.

Lua: 115 92 89 byte

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

accetta C[]to C[]wcome input; [] = a's o o's. Un input in minuscolo si tradurrà nel risultato.

versione lunga:

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

Esempi di output:

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

Modifica: modificato if then elsein and or. rimosso TUTTI gli spazi non stringa.

Anche tu lo provi qui: esegui Lua Online ma non sono riuscito a capire come usare il terminale, quindi l'ho messo in funzione.

Modifica: modificato l'utilizzo di "o" e rimosso () da :find. il merito va a Cyv per trovare quelle ottimizzazioni. Aggiunti "s" e modificati l=#i-3inl=#i-2

Con input che include "s" solo 88 byte:

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 byte

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

Provalo online!

PHP, 170 164 161 157 byte

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

Prende qualsiasi maiuscola. CaAaT, coOOOwqualunque cosa.

v2: non è necessario [wt] $. anche corretto ct
v3: char ct era tutto sbagliato, condensato $ a e $ e assegnazione
v4: salva 3 byte su $ af -> $ a
v5: salva 4 byte allineandolo (non mostrato)