Wszyscy wiedzą, że koty miauczą, ale wielu nie zdaje sobie sprawy z tego, że koty idą miau. W rzeczywistości długość dźwięków samogłoski wydawanych przez kota zależy od długości samogłoski, z którą się do niej odwołujesz.

W ten sam sposób, krowy idą muczą, ale coooow idą muczą

Wyzwanie

Masz napisać program, który pobiera jako dane wejściowe, słowo oznaczające kota i słowo oznaczające krowę, określ liczbę głównych samogłosek i wypisz odpowiednio jeden z następujących ciągów:

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

Gdzie []oznacza samogłosek, zgodnie z następującymi zasadami:

• Liczba e i o w „Meow” musi być zgodna z liczbą samogłosek znalezionych w słowie wejściowym.
• Liczba o w wyrazie „Moo” musi być dwukrotnie większa niż liczba samogłosek znalezionych w słowie wejściowym.

Program musi rozpoznać słowa wejściowe cati cow. Dane wejściowe mogą wykorzystywać dowolne, które są najwygodniejsze, ale dane wyjściowe muszą być pisane dużymi literami dokładnie tak, jak pokazano powyżej.

Retina , 57 49 44 43 41 bajtów

Tak blisko ... :) Pyth ...

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

Wypróbuj online.

Oczekuje, że dane wejściowe będą pisane dużymi literami jak Caaatlub Coooow.

Wyjaśnienie

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

Wyrażenie regularne dopasowuje całe wejście i przechwytuje samogłoski w grupie 1(nie potrzebujemy kotwic, ponieważ dopasowanie nie może się nie powieść i zachłannie dopasuje całe wejście). Podstawienie zapisuje to wejście i dołącza s go M, a następnie dwukrotnie samogłoski. Za dane wejściowe Caaati Coooowotrzymujemy:

Caaats go Maaaaaa
Coooows go Moooooooo

Dane wyjściowe dla krów są już prawidłowe. Musimy tylko coś zrobić z tymi kotami.

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

+Mówi Retina powtórzyć ten etap tak często, jak to możliwe. Wyrażenie regularne dopasowuje dwa as w ostatniej części łańcucha (zapewniamy to za pomocą $kotwicy, aby nie zastępować rzeczy w środku Caaats). Będzie to zasadniczo pasowało do wszystkiego po M, o ile ta część nadal ma as. Dwa as są usuwane, a cały sufiks po owinięciu e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Na koniec są dwa wiele ws, więc usuwamy te, które poprzedzają an o(aby upewnić się, że nie zepsujemy się ww Coooows):

wo
o

I zostaje nam:

Caaats go Meeeooow

LabVIEW, 58 LabVIEW Prymitywy

tworzenie takich ciągów jest uciążliwe ...

Najbardziej po lewej stronie widać dopasowanie wzorca, odpowiednio a + i o + szukają najmniejszej ilości as i os z rzędu.

Biorąc długość tych, tworzę 3 tablice 1 z długością os 1 z długością es i jedną z 2-krotną długością os.

Następnie wszystkie części są łączone. Najpierw oryginalne wejście, potem przejdź M wszystkie tablice, nieużywane są puste, więc zostaną zignorowane, a na koniec aw, jeśli dane wejściowe to koty. (Jeśli tak, jak znaleziono, będzie po meczu, jeśli nie, gdy mecz będzie pusty)

W przypadku Lolza zaimplementowałem również lisa z 6 różnymi wyjściami ^^

Pyth, 50 44 34

Pobiera dane wejściowe w formacie ["caat", "coow"].

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

Wypróbuj online.

Wyjaśniono:

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

Dzięki Jakube za znaczne skrócenie długości.

Perl, 66 61 55 54 bajtów

zawiera +1 dla -p

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

Dane wejściowe powinny być zgodne z /^C[ao]+[tw]$/(bez końca nowego wiersza!)
Zastosowanie:/bin/echo -n Caaat | perl -p 55.pl

Awaria

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

Poprzednia wersja:

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

Skomentowano :

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

Przykład: Caaat

• Capture $&as aand @las (a,a,a).
• Ustaw $xtrzy razy a, po czym 3 razy o: aaaooo.
• Przetłumacz wszystko aw $xcelu e: eeeooo. Liczba zamienników (0 lub dodatnich) służy jako wykrywacz kotów: ustaw $yna wtak, jeśli tak.
• Zmień wejście przez dodanie s go M, eeeoooa w.

• aktualizacja 61 : Zapisz 5 bajtów, używając listy zamiast łańcucha
• aktualizować 55 : Zapisz 6 bajtów przez inline, przypisując $\zamiast s/$/, a nie wymaga spływu przełamane na wejściu.
• aktualizować 54 : zapisz 1 bajt eliminując @l.

Python 2, 74 bajty

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

Pobiera dane wejściowe

Caaat lub Cooow

CJam ( 60 57 55 53 bajtów)

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

Demo online . Zakłada się, że dane wejściowe są pisane małymi literami.

Dla tej samej długości:

"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 bajtów

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

_{(łamanie wierszy liczy się tak samo jak średniki, więc dla zachowania przejrzystości łamane wiersze)}

Zaskakująco trudne wyzwanie. I jestem dość pewien, że można to jeszcze pograć w golfa.

Pobiera ciągi wejściowe jako $ai $b. Łączy je i rzuca je jako tablicę znaków, a następnie przepuszcza je przez pętlę %{}. Każda litera jest następnie sprawdzane, czy to -eqUAL się 'a'i związany zmienna licznik jest zwiększany odpowiednio. Następnie odejmujemy 4+$cod w $dcelu uwzględnienia catcww danych wejściowych i przystępujemy do formułowania zdań wyjściowych, modyfikując razy wyjściowe samogłosek odpowiadające im liczniki. (W PowerShellu, 'e'*3że wydajność 'eee', na przykład).

Prawie podobne do odpowiedzi @ omulusnr, ale daje to prawidłowe wyjście, a także w danych wejściowych nie jest rozróżniana wielkość liter.

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 bajty

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

Nie golfowany:

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

Przyjmuje kota lub krowę dowolną literę. Możesz spróbować tutaj:

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

MATLAB: 190 152 118 bajtów

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

Nie golfowany:

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

Testy:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

PS: Dzięki @Kenney za miłą sugestię (patrz komentarze)!

PHP, 138 bajtów

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

czytelny:

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

próbowałem krócej, ale nie będzie działać w 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

Pierwsza wersja ze zmiennymi i objaśnieniem, 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}]);

Objaśnienie: L wie, które zwierzę zawiera daną literę. S wie, co powtarzają. On zna zakończenie. Aby to działało, musisz mieć włączone „automatyczne nadawanie”, ale powinno to być domyślnie we wszystkich oktawach, których użyłem. Oczywiście istnieją krótsze sposoby, na przykład regexprep polecenia (wyrażenia regularne z zamianą), ale w odpowiedziach pojawiło się już kilka takich podejść, więc byłoby to nudne.

Edycja: Pomijanie zmiennych, które występują tylko raz, przy użyciu indeksowania oktawy w locie (nie wiem, jak to się naprawdę nazywa) i dodanie „i”, zmiennej ciągu wejściowego:

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

Wypróbuj tutaj: https://jsbin.com/guqaxejiha/1/edit?js,console

Lua, 121 90 bajtów

121 bajtów

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 bajtów

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

Uwzględnia wielkość liter w danych wejściowych, takich jak „Caats” lub „Coooows”. Ponieważ nie ma wymagań dotyczących nieprawidłowych danych wejściowych, dane wyjściowe mogą być dziwne dla, powiedzmy, „Lisów” lub „Wołów”. : P

Bez golfa

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

Zaktualizuj do 90 bajtów: zastąpiono strukturę if-control operatorami logicznymi, zoptymalizowano konkatenację ciągów, dodając więcej danych w deklaracji i. Usunięto nawias włączony i:find("w"). Co ciekawe, przechowywanie "o"w zmiennej pozwala zaoszczędzić kilka bajtów podczas używania rep, ale przyniosłoby efekt przeciwny do zamierzonego przy pomocy "w"lub "e". Im więcej wiesz.

Lua: 115 92 89 bajtów

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

przyjmuje C[]tlub C[]wjako dane wejściowe; [] = a lub O. Dane wejściowe o niskiej wartości zostaną przełożone na wynik.

długa wersja:

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

Przykładowe wyniki:

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

Edytuj: zmieniono if then elsena and or. usunięto WSZYSTKIE spacje nie łańcuchowe.

Możesz też spróbować tutaj: Uruchom Lua Online, ale nie mogłem wymyślić, jak korzystać z terminala, więc włączyłem tę funkcję.

Edycja: zmieniono użycie „o” i usunięto () z :find. uznanie dla Cyv za znalezienie tych optymalizacji. Dodano „s” i zmieniono l=#i-3nal=#i-2

Z danymi wejściowymi zawierającymi „s” tylko 88 bajtów:

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 bajtów

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

Wypróbuj online!

PHP, 170 164 161 157 bajtów

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

Dokonuje jakiejkolwiek kapitalizacji. CaAaT, coOOOwcokolwiek.

v2: tak naprawdę nie potrzebuję [wt] $. również poprawiono char ct
v3: char ct wszystko było niepoprawne, skondensowane $ a i $ e przypisanie
v4: zapisz 3 bajty na $ af -> $ a
v5: zapisz 4 bajty przez onelining go (nie pokazano)