모두 고양이가 야옹이는 것을 알고 있지만, 많은 사람들이 모르는 것은 캐 이머가 meeeeoooow입니다. 실제로, 고양이가 만드는 모음 소리의 길이는 당신이 그것을 다루는 모음의 길이에 달려 있습니다.

같은 방식으로 젖소는 매끄럽게 움직입니다.

도전

입력, 단어 의미 고양이 및 단어 의미 소 를 취하는 프로그램을 작성하고 주 모음 수를 결정한 후 다음 중 하나를 적절하게 인쇄해야합니다.

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

어디 []다음 규칙에 따라, 모음을 의미합니다 :

• "Meow"의 e와 o의 수는 입력 단어에서 찾은 모음 수와 일치해야합니다.
• "Moo"에있는 o의 수는 입력 단어에있는 모음 수의 두 배 여야합니다.

이 프로그램은 입력 된 단어를 인식해야 cat하고 cow. 입력은 가장 편리한 대문자를 사용할 수 있지만 출력은 위에 표시된대로 정확하게 대문자를 사용해야합니다.

망막 , 57 49 44 43 41 바이트

너무 가까이 ... :) Pyth ...

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

온라인으로 사용해보십시오.

입력이 Caaat또는 과 같이 대문자로 사용될 것으로 예상합니다 Coooow.

설명

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

정규 표현식은 전체 입력과 일치하고 그룹의 모음을 캡처합니다 1(일치 할 수 없으며 전체 입력과 욕심스럽게 일치하므로 앵커가 필요하지 않습니다). 대체는 해당 입력을 다시 쓰고 s go M모음 뒤에 두 배를 추가 합니다. 입력 Caaat과의 Coooow경우 다음을 얻습니다.

Caaats go Maaaaaa
Coooows go Moooooooo

젖소의 생산량은 이미 정확합니다. 우리는 그 고양이들에 대해 뭔가를해야합니다.

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

는 +망막 가능한 한 자주이 단계를 반복 알려줍니다. 정규식 a은 문자열의 마지막 부분에서 두 개의을 일치 시킵니다 (우리는 $앵커로 이것을 보장하여 내부의 것을 대체하지 않습니다 Caaats). 이것은 M부분이 여전히을 갖는 한 본질적으로 이후의 모든 항목과 일치 a합니다. 두 개의 as가 제거되고 접미어가 붙은 후 전체 접미사가 제거됩니다 e...ow.

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

마지막으로,이 개 많습니다 w우리가 선행 자들을 제거 할 수 있도록 결과에들, o(확인하기 위해 우리가 엉망하지 않을 w에서를 Coooows)

wo
o

그리고 우리는 남았습니다.

Caaats go Meeeooow

LabVIEW, 58 LabVIEW 프리미티브

이런 식으로 문자열을 만드는 것은 고통입니다 ...

가장 왼쪽에있는 vi는 패턴 일치이며, a +와 o +는 각각 행에서 as와 os의 가장 큰 양을 검색합니다.

그것들의 길이를 취하면 길이가 1 인 lenght os가있는 3 개의 배열 1과 길이가 2 배인 1 개의 배열을 만듭니다.

그런 다음 모든 부품이 합쳐집니다. 먼저 원래 입력 후 모든 배열 M을 사용하고 사용되지 않은 입력은 비어 있으므로 무시하고 입력이 고양이 인 경우 aw입니다. (발견 된대로 일치가 비어 있지 않은 경우, 일치 한 후에 있음)

lolz의 경우 6 가지 출력으로 여우를 구현했습니다 ^^

피스, 50 44 34

형식으로 입력을 ["caat", "coow"]받습니다.

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

온라인으로 사용해보십시오.

설명 :

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

길이를 크게 줄인 Jakube 에게 감사드립니다 .

펄, 66 61 55 54 바이트

+1 포함 -p

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

입력은 다음 /^C[ao]+[tw]$/줄 바꿈 을 준수 하지 않아야합니다.
사용법 :/bin/echo -n Caaat | perl -p 55.pl

고장

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

이전 버전:

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

댓글 :

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

예: Caaat

• 캡처 $&로 a와 @l같은 (a,a,a).
• 설정 $x세 번 a3 번 다음에 o: aaaooo.
• 모든 번역 a에 $x로를 e: eeeooo. 교체 (0 또는 양의 어느 하나)의 수는 고양이 검출기로서 기능 : 집합 $y에 w그렇다면.
• 추가하여 입력을 변경 s go M, eeeooo하고 w.

• 업데이트 61 : 문자열 대신 list를 사용하여 5 바이트 저장
• 업데이트 55 : 인라인, $\대신 할당 s/$/및 입력에 후행 줄 바꿈이 없어 6 바이트를 절약 합니다.
• 업데이트 54 : @l을 제거하여 1 바이트를 저장하십시오.

파이썬 2, 74 바이트

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

입력을받습니다

Caaat 또는 Cooow

CJam ( 60 57 55 53 바이트)

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

온라인 데모 . 입력은 소문자 인 것으로 가정합니다.

같은 길이의 경우 :

"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, 135132 바이트

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

_{(줄 바꿈은 세미콜론과 동일하므로 명확성을 위해 줄 바꿈)}

놀랍도록 까다로운 도전. 그리고 나는 이것이 더 골프를 칠 수 있다고 확신합니다.

입력 문자열을 $aand로 사용 $b합니다. 그것들을 연결하고 문자 배열로 캐스팅 한 다음 루프를 통해 파이프합니다 %{}. 그런 다음 각 문자가 -eq최종 문자인지 확인 'a'하고 관련 카운터 변수가 적절하게 증가합니다. 우리는 다음 빼기 4+$c에서 $d설명하기 위해 catcw모음 출력 시간을 해당 카운터를 수정, 입력, 그리고 출력 문장을 공식화로 진행합니다. 예를 들어 PowerShell에서는 'e'*3을 산출 'eee'합니다.

@omulusnr의 답변과 거의 비슷하지만 올바른 출력을 생성하고 입력은 대소 문자를 구분하지 않습니다.

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

스위프트 2, 3̶8̶1̶ 333 바이트

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

언 골프 드 :

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

고양이 나 소에게 대문자를 사용합니다. 여기에서 시도해 볼 수 있습니다.

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

MATLAB : 190 152 118 바이트

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

언 골프 드 :

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

테스트 :

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

추신 : 좋은 제안을 한 @Kenney에게 감사드립니다 (의견 참조)!

PHP, 138 바이트

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

읽을 수있는 :

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

더 짧게 시도했지만 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)));

=)

옥타브, 126 , 108

변수와 설명이있는 첫 번째 버전, 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}]);

설명 : L은 어떤 동물에 어떤 문자가 들어 있는지 알고 있습니다. S는 그들이 무엇을 반복하는지 알고있다. e는 결말을 알고 있습니다. 이 기능을 사용하려면 "자동 브로드 캐스트"를 켜야하지만 기본적으로 내가 사용한 모든 옥타브에 있어야합니다. 물론 regregrep 명령 (예 : 대체 표현식)과 같은 짧은 방법이 있지만 이미 답변에 여러 가지 접근 방식이 이미 있었으므로 지루할 것입니다.

편집 : 옥타브 on-the-fly 인덱싱 (실제로 무엇을 호출하는지 알지 못함)을 사용하고 입력 문자열 변수 "i"를 추가하면 한 번만 발생하는 변수를 건너 뜁니다.

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

자바 스크립트 (ES2015) 78 77

s=>s+'s go M'+(l=s.length-1,w=s[l]<'u',Array(l).join(w?'eo':'oo')+(w?'w':''))

여기에서보십시오 : https://jsbin.com/guqaxejiha/1/edit?js,console

루아, 121 90 바이트

121 바이트

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 바이트

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

'Caats'또는 'Coooows'와 같은 입력은 대소 문자를 구분합니다. 유효하지 않은 입력에 대한 요구 사항이 없으므로 'Foxes'또는 'Oxen'과 같이 출력이 이상 할 수 있습니다. :피

언 골프

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

90 바이트 로 업데이트 : if-control 구조를 논리 연산자로 대체하고의 선언에 더 많은 데이터를 추가하여 문자열 연결을 최적화했습니다 i. 의 괄호를 제거했습니다 i:find("w"). 흥미롭게도, "o"변수에 저장하면을 사용할 때 몇 바이트가 절약 rep되었지만 "w"or 과는 비생산적입니다 "e". 더 많이 알수록

루아 : 115 92 89 바이트

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

소요 C[]t또는 C[]w입력으로서; [] = a 또는 o입니다. 소문자 입력은 결과로 변환됩니다.

긴 버전 :

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

출력 예 :

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

편집 :으로 변경 if then else되었습니다 and or. 문자열이 아닌 모든 공간을 제거했습니다.

또한 당신은 고양이를 시험해보십시오 : Lua Online을 실행 하지만 터미널을 사용하는 방법을 알 수 없으므로 기능에 넣었습니다.

편집 : "o"의 사용법을 변경하고에서 ()을 제거했습니다 :find. 크레딧은 이러한 최적화를 찾기 위해 Cyv 로갑니다 . "S"추가 및 변경 l=#i-3에l=#i-2

"s"를 포함한 입력의 경우 88 바이트 만 :

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

다트 , 114112110104102100 바이트

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

온라인으로 사용해보십시오!

PHP, 170 164 161 157 바이트

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

대문자를 사용합니다. CaAaT, coOOOw뭐든간에

v2 : 실제로 [wt] $가 필요하지 않습니다. 또한 char ct
v3 수정 : char ct는 모두 잘못되었고 $ a 및 $ e 할당이 압축되었습니다
v4 : $ af- > $ a v5 에 3 바이트
저장 : 1 바이트로 4 바이트 저장 (표시되지 않음)