Jeder weiß, dass Katzen miauen, aber was viele nicht merken, ist, dass die Katzen miauen. Tatsächlich hängt die Länge des Vokals, den die Katze macht, von der Länge des Vokals ab, mit dem Sie ihn ansprechen.

Auf die gleiche Weise gehen Kühe moo, aber coooows gehen moooooooo

Herausforderung

Sie müssen ein Programm schreiben, das als Eingabe ein Wort für Katze und ein Wort für Kuh verwendet, die Anzahl der Hauptvokale bestimmen und gegebenenfalls eine der folgenden Zeichenfolgen drucken:

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

Wobei []für die Vokale nach folgenden Regeln steht:

• Die Anzahl der e und o in "Meow" muss mit der Anzahl der im Eingabewort gefundenen Vokale übereinstimmen.
• Die Anzahl der O's in "Moo" muss doppelt so groß sein wie die Anzahl der Vokale im Eingabewort.

Das Programm muss die eingegebenen Wörter catund erkennen cow. Für die Eingabe kann jede am besten geeignete Groß- und Kleinschreibung verwendet werden, die Ausgabe muss jedoch genau wie oben angegeben großgeschrieben werden.

Retina , 57 49 44 43 41 Bytes

So nah ... :) Pyth ...

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

Probieren Sie es online aus.

Erwartet, dass die Eingabe wie Caaatoder aktiviert wird Coooow.

Erläuterung

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

Der reguläre Ausdruck stimmt mit der gesamten Eingabe überein und erfasst die Vokale in Gruppen 1(wir benötigen keine Anker, da die Übereinstimmung nicht fehlschlagen kann und die gesamte Eingabe gierig übereinstimmt). Die Ersetzung schreibt diese Eingabe zurück und hängt sie an s go M, gefolgt von den doppelten Vokalen. Für Eingaben Caaatund erhalten Coooowwir:

Caaats go Maaaaaa
Coooows go Moooooooo

Die Ausgabe für Kühe ist bereits korrekt. Wir müssen nur etwas gegen diese Katzen unternehmen.

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

Der +fordert Retina auf, diesen Schritt so oft wie möglich zu wiederholen. Der reguläre Ausdruck stimmt mit zwei as im letzten Teil der Zeichenfolge überein (wir stellen dies mit dem $Anker sicher , damit wir keine Dinge im Inneren ersetzen Caaats). Dies wird im Wesentlichen alles danach passen M, solange dieser Teil noch as hat. Die zwei as werden entfernt und das gesamte Suffix, nachdem es eingewickelt wurde e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Schließlich gibt es zwei viele ws im Ergebnis, so dass wir diejenigen zu entfernen , die ein vorausgehen o(um sicherzustellen , sind wir nicht das vermasseln win Coooows):

wo
o

Und wir bleiben mit:

Caaats go Meeeooow

LabVIEW, 58 LabVIEW-Grundelemente

Saiten wie diese zu erstellen ist ein Schmerz ...

Die am weitesten links stehenden vis sind Pattern Matching, a + und o + suchen jeweils nach der verzögertesten Menge von as und os in einer Reihe.

Die Länge von denen nehmend, verursache ich 3 Reihen 1 mit Länge OS 1 mit Länge ES und eine mit 2mal Länge OS.

Dann werden alle Teile zusammengesetzt. Zuerst die ursprüngliche Eingabe, dann gehen M alle Arrays, die nicht verwendeten sind leer, so dass sie ignoriert werden, und schließlich aw, wenn die Eingabe Katzen waren. (Wenn wie gefunden, wird es nach dem Spiel sein, wenn nicht nach dem Spiel leer ist)

Für die lolz habe ich auch den Fuchs mit 6 verschiedenen Ausgängen implementiert ^^

Pyth, 50 44 34

Übernimmt Eingaben im Format ["caat", "coow"].

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

Probieren Sie es online aus.

Erklärt:

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

Vielen Dank an Jakube für die erhebliche Verkürzung der Länge.

Perl, 66 61 55 54 Bytes

beinhaltet +1 für -p

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

Eingang wird voraussichtlich entsprechen /^C[ao]+[tw]$/(keine Newline!)
Verbrauch:/bin/echo -n Caaat | perl -p 55.pl

Nervenzusammenbruch

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

Vorherige Version:

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

Kommentiert :

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

Beispiel: Caaat

• Erfassen $&als aund @lals (a,a,a).
• Stellen Sie $xzu dreimal adurch 3 mal gefolgt o: aaaooo.
• Alles übersetzen ain $xzu e: eeeooo. Die Anzahl der Ersetzungen (entweder 0 oder positiv) dient als cat-Detektor: Satz $yan wfalls ja.
• Ändern Sie die Eingabe durch Anhängen s go M, eeeooound w.

• Update 61 : Speichern Sie 5 Bytes, indem Sie Liste anstelle von Zeichenfolge verwenden
• Update 55 : Sparen Sie 6 Bytes durch Inlining, Zuweisen $\anstatt s/$/und ohne nachfolgende Zeilenumbrüche in der Eingabe.
• Update 54 : Sparen Sie 1 Byte, indem Sie @l entfernen.

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

Übernimmt die Eingabe

Caaat oder Cooow

CJam ( 60 57 55 53 Bytes)

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

Online-Demo . Es wird angenommen, dass die Eingabe in Kleinbuchstaben erfolgt.

Für die gleiche Länge:

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

_{(Zeilenumbrüche werden wie Semikolons gezählt, daher zur Verdeutlichung durch Zeilenumbrüche getrennt.)}

Überraschend knifflige Herausforderung. Und ich bin mir ziemlich sicher, dass dies weiter golfen werden kann.

Übernimmt die Eingabezeichenfolgen als $aund $b. Verkettet sie und wandelt sie in ein Zeichen-Array um, das dann durch eine Schleife geleitet wird %{}. Jeder Buchstabe wird dann auf seine -eqAktualität überprüft 'a'und die zugehörige Zählervariable entsprechend inkrementiert. Wir subtrahieren dann 4+$cvon $d, um dies catcwin der Eingabe zu berücksichtigen , und fahren mit der Formulierung der Ausgabesätze fort, wobei wir die Ausgabe der Vokale mit den entsprechenden Zählern modifizieren. (In PowerShell 'e'*3würde 'eee'zum Beispiel ergeben.)

Fast ähnlich der Antwort von @ omulusnr, aber dies erzeugt die korrekte Ausgabe und auch die Eingabe ist unabhängig von Groß- und Kleinschreibung.

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

Nimmt Katze oder Kuh Großbuchstaben. Sie können es hier ausprobieren:

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

Tests:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PS: Danke an @Kenney für den netten Vorschlag (siehe Kommentare)!

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

lesbar:

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

versucht kürzer, aber nicht in PHP arbeiten:

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

=)

OKTAVE, 126 , 108

Erste Version mit Variablen und Erklärung, 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}]);

Erklärung: L weiß, welches Tier welchen Buchstaben enthält. S weiß, was sie wiederholen. Wir kennen das Ende. Sie müssen "Automatic Broadcasting" aktiviert haben, damit dies funktioniert, aber es sollte standardmäßig in allen von mir verwendeten Oktaven sein. Natürlich gibt es kürzere Wege mit zum Beispiel dem Befehl regexprep (reguläre Ausdrücke mit Ersetzung), aber es gab bereits mehrere solcher Ansätze in den Antworten, so dass dies langweilig wäre.

Bearbeiten: Überspringen von Variablen, die nur einmal vorkommen, Verwenden von Octave-On-the-Fly-Indizierung (weiß nicht, wie es für real heißt) und Hinzufügen von "i", Eingabezeichenfolgenvariable:

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

Versuchen Sie es hier: 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"))

Nimmt Eingaben wie "Caats" oder "Coooows" unter Berücksichtigung der Groß- und Kleinschreibung auf. Da es keine Anforderungen für ungültige Eingaben gibt, kann die Ausgabe für beispielsweise "Füchse" oder "Ochsen" seltsam sein. : 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")
      )

Update auf 90 Bytes: Ersetzte if-Kontrollstruktur durch logische Operatoren, optimierte String-Verkettung durch Anhängen weiterer Daten in der Deklaration von i. Klammer auf entfernt i:find("w"). Interessanterweise hat das Speichern "o"in einer Variablen bei der Verwendung einige Bytes gespart rep, wäre jedoch mit "w"oder kontraproduktiv "e". Je mehr du weisst.

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

nimmt C[]toder C[]wals Eingabe; [] = a's oder o's. Ein Low-Case-Eingang wird in das Ergebnis übersetzt.

lange Version:

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

Beispielausgaben:

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

Bearbeiten: geändert if then elsein and or. ALLE Leerzeichen, die keine Zeichenfolgen sind, wurden entfernt.

Sie können es auch hier ausprobieren: Führen Sie Lua Online aus, aber ich konnte nicht herausfinden, wie das Terminal verwendet wird, und habe es in eine Funktion eingefügt.

Bearbeiten: Die Verwendung von "o" wurde geändert und von () entfernt :find. Kredit geht an CYV für diese Optimierungen zu finden. "S" hinzugefügt und geändert l=#i-3zul=#i-2

Bei Eingabe mit "s" nur 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))

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

Probieren Sie es 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";

Nimmt jede Großschreibung. CaAaT, coOOOwWas auch immer.

v2: brauche nicht wirklich [wt] $. auch char ct korrigiert
v3: char ct war alles falsch, kondensiert ein und $ e Zuordnung $
v4: save 3 Bytes auf $ af - a> $
v5: save 4 Bytes von onelining es (nicht dargestellt)