हर कोई जानता है कि बिल्लियां म्याऊ जाती हैं, लेकिन बहुतों को यह एहसास नहीं होता है कि कौआ मय्येउवॉ जाता है। वास्तव में, स्वर की लंबाई लगता है कि बिल्ली बनाती है यह उस स्वर की लंबाई पर निर्भर करता है जिसके साथ आप इसे संबोधित करते हैं।

उसी तरह, गायों को भी जाना जाता है, लेकिन सहकर्मियों को मूहुवो जाता है

चुनौती

आपको एक प्रोग्राम लिखना है जो इनपुट के रूप में लेता है, एक शब्द अर्थ बिल्ली, और एक शब्द अर्थ गाय, मुख्य स्वरों की संख्या निर्धारित करें, और निम्न में से किसी एक को प्रिंट करें, जैसा कि उपयुक्त हो:

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

[]निम्नलिखित नियमों के अनुसार, स्वरों के लिए कहां खड़ा है:

"मेव" में ई और ओ की संख्या दोनों को इनपुट शब्द में पाए जाने वाले स्वरों की संख्या से मेल खाना चाहिए।
"मू" में ओ की संख्या इनपुट शब्द में पाए जाने वाले स्वरों की संख्या से दोगुनी होनी चाहिए।

कार्यक्रम को इनपुट शब्दों catऔर पहचानना होगा cow। इनपुट किसी भी कैपिटलाइज़ेशन का उपयोग कर सकता है जो सबसे सुविधाजनक है, लेकिन आउटपुट को कैपिटलाइज़ किया जाना चाहिए जैसा कि ऊपर दिखाया गया है।

code-golf string

— सोनिक एटम
स्रोत

42

क्यू एक निश्चित लोमड़ी के बारे में मजाक

— मार्टिन एंडर

7

मुझे यकीन नहीं है कि मैं चुनौती को समझता हूं। इनपुट एक या दो शब्द है? क्या आप कुछ उदाहरण इनपुट / आउटपुट जोड़े दे सकते हैं?

— ज़गरब

31

@ मार्टिनबटनर मुझे यकीन नहीं है अगर मुझे पता है कि आप किस लोमड़ी के बारे में बात कर रहे हैं। जोग मेरी याददाश्त, इसे क्या कहते हैं?

— DJMcMayhem

4

आप ई और ओ की संख्या निर्दिष्ट करते हैं, लेकिन उनका क्रम नहीं। है Meooeoewके लिए एक वैध उत्पादन Caaatउदाहरण के लिए,?

— पीटर ओल्सन

10

लोमड़ी की खातिर सजा के साथ बंद करो!

— यूमेल

17

रेटिना , 57 49 44 43 41 बाइट्स

~~इतना करीब ...~~ :) पायथ ...

.(.+).
$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। दो aएस हटाए जाते हैं और पूरे प्रत्यय को इसमें लपेटने के बाद e...ow:

Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

अंत में, वहाँ दो कई हैं wपरिणाम में, इसलिए हम एक उन है कि पूर्व में होना हटाने o(सुनिश्चित करें कि हम खिलवाड़ नहीं कर रहे हैं करने के लिए wमें Coooows):

wo
o

और हम साथ रह गए हैं:

Caaats go Meeeooow

— मार्टिन एंडर
स्रोत

11

लैबव्यू, 58 लैबव्यूड प्राइमेटिव

इस तरह से दर्द पैदा करना ...

सबसे बाईं ओर पैटर्न मिलान, एक और ओ + क्रमशः एक पंक्ति में के रूप में और ओएस की सबसे बड़ी राशि के लिए खोज कर रहे हैं।

जो मैं ले रहा हूँ, उनमें से 3 ऐरे 1 को लिन्थ अस के साथ 1 लिन्स्ट एसस के साथ और 2 बार लश्कर ओ एस के साथ लें।

फिर सभी भागों को एक साथ रखा जाता है। पहले मूल इनपुट, उसके बाद M सभी Arrays जाएं, अप्रयुक्त एक खाली हैं इसलिए उन्हें नजरअंदाज कर दिया जाएगा, और अंत में इनपुट के बिल्लियों होने पर जागेगा। (जैसा कि वहां पाया गया कि मैच के बाद होगा, अगर मैच खाली नहीं है)

लोलज़ के लिए मैंने 6 अलग-अलग आउटपुट ^ ^ के साथ लोमड़ी को भी लागू किया

— Eumel
स्रोत

मेरे पास परीक्षण का कोई तरीका नहीं है, लेकिन अगर यह आपके कहे अनुसार काम करता है तो मैं बहुत प्रभावित हुआ हूँ!

— सोनिक एटम

क्या आप ब्याज के बारे में स्पष्टीकरण दे सकते हैं?

— सोनिक एटम

स्पष्टीकरण btw है, यह पूछने में संकोच न करें कि क्या कोई सवाल है

— Eumel

कोड-गोल्फ एक मालिक की तरह। वाह।

— जकूजी

7

पायथ, 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"

लंबाई में बड़ी कटौती के लिए जकुबे का धन्यवाद ।

— ल्यूक
स्रोत

कुछ छोटी बातें: आप पहले जगह ले सकता है jkके साथ s, दूसरी को दूर jk(यह सब पर कुछ भी नहीं है), और की जगह "w\n"के साथ \wb।

— जकुबे

साथ ही, आपका अधिकांश कोड आपके कोड, जैसे r.Q3और अन्य सामान में दो बार दिखाई देता है । आप एक बाइनरी_मैप का उपयोग कर सकते हैं और 10 अतिरिक्त वर्णों को बचा सकते हैं। Pj.bs[rN3"s go M"S*-lN2+Y\o\w)Q"eo। यकीन नहीं है, अगर आपके पास पहले से ही नक्शे के साथ अनुभव है, अगर आपके पास कोई प्रश्न है, तो मैं आपको पायथ चैट पर समझा सकता हूं ।

— जकुबे

अच्छा धन्यवाद। मुझे लगा कि मैं ऐसा कुछ कर सकता हूं लेकिन यह नहीं जानता कि कैसे।

— ल्यूक

यह बहुत कुशल है। इसमें अधिक उत्थान होना चाहिए।

— सोनिक एटम

2

फिर से नहीं।

— OldBunny2800

5

पर्ल, 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 : स्ट्रिंग के बजाय सूची का उपयोग करके 5 बाइट्स सहेजें
55 अपडेट करें : 6 बाइट्स को इनलाइन करके सेव करें, $\इसके बजाए असाइन करें s/$/, और इनपुट में कोई अनुगामी न्यूलाइन की आवश्यकता नहीं है।
अपडेट 54 : @ एल को समाप्त करके 1 बाइट बचाएं।

— केनी
स्रोत

4

पायथन 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

— TFeld
स्रोत

2

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

— पीटर टेलर
स्रोत

1

पॉवरशेल, 135 132 बाइट्स

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

_{(लाइनब्रेक को अर्धविराम के समान गिना जाता है, इसलिए स्पष्टता के लिए लाइन-ब्रेक किया गया)}

आश्चर्यजनक रूप से मुश्किल चुनौती। और मुझे पूरा यकीन है कि इसे और आगे बढ़ाया जा सकता है।

के रूप में $aऔर इनपुट तार लेता है $b। उन्हें समेटता है और उन्हें चार-सरणी के रूप में रखता है, फिर एक लूप के माध्यम से पाइप करता है %{}। प्रत्येक पत्र को तब चेक किया जाता है यदि वह -equal है 'a'और संबंधित काउंटर चर उचित रूप से बढ़ा हुआ है। फिर हम इनपुट के लिए खाते 4+$cसे घटाते हैं , और आउटपुट वाक्यों को बनाने के लिए आगे बढ़ते हैं, स्वरों के उत्पादन के समय को इसी काउंटरों को संशोधित करते हैं। (PowerShell में, उदाहरण के लिए, उपज देगा )।$dcatcw'e'*3'eee'

— AdmBorkBork
स्रोत

1

लगभग @ 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':'';

— blackpla9ue
स्रोत

$p=$argv[1];preg_match("/c([ao]+)/i",$p,$e);$l=strlen($e[1]);$s=$k=strcmp($e[0][1],'o')?'eo':'oo';$r='str_repeat';echo $p,' go M',$r($s[0],$l),$r($s[1],$l),$k?'w':'';

166 बाइट्स के लिए थोड़ा सा छोटा

— Tschallacka

1

स्विफ्ट 2, 3ift8̶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" :""))}

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

बिल्ली या गाय को कोई भी पूंजीकरण ले लेता है। आप इसे यहाँ आज़मा सकते हैं:

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

— फिदेल एडुआर्डो लोपेज़
स्रोत

2

यह कैसे इनपुट लेता है?

— एक

इस उदाहरण में कोई इनपुट नहीं है, मैंने इसे खेल के मैदान पर परीक्षण के लिए बनाया है, इसलिए वहाँ पर कोई इनपुट नहीं है, परीक्षण के लिए var का उपयोग करना चाहिए

— फिदेल एडुआर्डो लोपेज़

1

मुझे लगता है कि यह तो एक स्निपेट बनाता है। इसे वैध होने के लिए एक कार्य या पूर्ण कार्यक्रम होना चाहिए। : /

— एक स्पेगेटो

1

ठीक है, मैंने इसे एक समारोह बनाया ..

— फिदेल एडुआर्डो लोपेज़

1

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

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

टेस्ट:

caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

पुनश्च: अच्छे सुझाव के लिए @Kenney को धन्यवाद (टिप्पणी देखें)!

— brainkz
स्रोत

disp( (b>0)*[...] + (c>0)*[...] )यहां काम करेंगे ?

— केनी

अच्छा सुझाव @Kenney

— brainkz

1

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

=)

— Cottton
स्रोत

1

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

स्पष्टीकरण: एल जानता है कि किस जानवर में कौन सा पत्र है। एस जानता है कि वे क्या दोहराते हैं। ई अंत जानता है। आपको काम करने के लिए "स्वचालित प्रसारण" चालू करना होगा, लेकिन यह उन सभी ऑक्टेव्स में डिफ़ॉल्ट रूप से होना चाहिए जिनका मैंने उपयोग किया है। बेशक उदाहरण कमांड रीजेक्सपर्प (प्रतिस्थापन के साथ नियमित अभिव्यक्ति) के लिए छोटे तरीके मौजूद हैं, लेकिन उत्तर में पहले से ही कई ऐसे दृष्टिकोण हैं, ताकि यह उबाऊ हो।

संपादित करें: स्किपिंग चर जो केवल एक बार होते हैं, ओक्टेव ऑन-द-फ्लाई इंडेक्सिंग का उपयोग करें (पता नहीं कि इसे वास्तविक के लिए क्या कहा जाता है) और "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}]);

— mathreadler
स्रोत

1

जावास्क्रिप्ट (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

— पाव्लो
स्रोत

Caaat पर काम नहीं करता है, आउटपुट 'Caaats Meoeoeow जाता है और होना चाहिए' Caaats जाना Meeeooow

— फिदेल एडुआर्डो लोपेज़

@ FidelEduardoLópez चुनौती में आदेश को निर्दिष्ट नहीं किया गया है: "ईव्स और ओ की संख्या" मेव "में दोनों को इनपुट शब्द में पाए गए स्वरों की संख्या से मेल खाना चाहिए।"

— पावलो

मुझे लगता है कि तुम सही हो .. मजेदार me बिल्लियाँ तुम्हारे पास हैं :)

— फिदेल एडुआर्डो लोपेज़

0

लूआ, 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"))

Ats कैट्स ’या 'कोव्स’ केस-संवेदी जैसे इनपुट लेता है। चूंकि अमान्य इनपुट के लिए कोई आवश्यकता नहीं है, इसलिए आउटपुट 'फ़ॉक्स' या 'ऑक्सन' के लिए अजीब हो सकता है। : पी

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

90 बाइट्स के लिए अद्यतन: तार्किक संचालकों के साथ अगर नियंत्रण संरचना को बदला गया है, तो घोषणा में अधिक डेटा जोड़कर स्ट्रिंग स्ट्रिंग को अनुकूलित किया गया है i। पर कोष्ठक हटा दिया i:find("w")। दिलचस्प रूप से पर्याप्त है, "o"एक चर के लिए भंडारण करते समय कुछ बाइट्स का उपयोग करते हुए बचाया rep, लेकिन "w"या के साथ उल्टा होगा "e"। जितना अधिक आप जानते हैं।

— Cyv
स्रोत

0

लुआ: 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's एक Lowecase इनपुट परिणाम में अनुवाद करेगा।

दीर्घ संस्करण:

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। सभी गैर स्ट्रिंग स्थान को हटा दिया गया है।

इसके अलावा, आप इसे यहाँ आज़माएँ: लुआ ऑनलाइन का निष्पादन करें, लेकिन मैं यह पता नहीं लगा सका कि टर्मिनल का उपयोग कैसे किया जाए इसलिए मैंने इसे एक फंक्शन में रखा है।

संपादित करें: "ओ" का बदला हुआ उपयोग और इससे () हटाया गया :find। उन अनुकूलनों को खोजने के लिए साइव को श्रेय जाता है । "एस" जोड़ा गया और बदल l=#i-3गयाl=#i-2

केवल 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))

— CHlM3RA
स्रोत

इनपुट बिल्ली या गाय होना चाहिए न कि बिल्ली, गाय। और बड़ा नहीं करता है। 'कैट्स' आउटपुट 'कैट गो मेव' होना चाहिए 'कैट्स गो मेव'

— फिदेल एडुआर्डो लोपेज

@ फिदेलुअर्दो लोपेज़ मैं पहले पर सहमत हूँ दूसरे पर नहीं। शब्द के अनुसार बिल्ली का अर्थ है, और एक शब्द का अर्थ गाय बिल्लियों की अनुमति है, लेकिन इनपुट शब्दों केcatcow अनुसार और नहीं । इनपुट किसी भी कैपिटलाइज़ेशन का उपयोग कर सकते हैं और बिल्ली या बिल्ली को बोल्ट मान्य होना चाहिए।

— CHlM3RA

इस बात से सहमत। इनपुट किसी भी पूंजीकरण का उपयोग कर सकता है, लेकिन आउटपुट को हमेशा C [] ts go M [] w के रूप में कैपिटल किया जाना चाहिए, है ना?

— फिदेल एडुआर्डो लोपेज

0

डार्ट , 114 112 110 104 102 100 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-2 बाइट्स: यू ऑफ़सेट की गणना को कम करने के लिए जिस तरह से यू ऑफ़सेट की गणना की जाती है उसे बदला जाता है

-2 बाइट्स: चैक को पहले पैडिंग में चौड़ाई पर ले जाया गया, न कि कैरेक्टर में

-6 बाइट्स: गाय / बिल्ली की जांच में बदलाव

-2 बाइट्स: वेरिएबल असाइनमेंट से छुटकारा मिला

-2 बाइट्स: 2 * (s.length + 1) पर पितृत्व की कम हो गई

— Elcan
स्रोत

-1

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 की जरूरत नहीं है। यह भी सही किया ct
v3: char ct सभी गलत था, संघनित $ a और $ e असाइनमेंट
v4: $ 3 पर 3 बाइट्स बचाएं -> $ a
v5: 4 बाइट्स को ऑनलाइन करके सेव करें (दिखाया नहीं गया)

— romulusnr
स्रोत

घटाया नहीं, लेकिन आउटपुट गलत है: गायब है $argv[0]."s go "। इसे आज़माएँ

preg_match("/(?i)c([ao]+)/",$x=$argv[1],$e);$a=$e[1][0]=="a"?"ew":"o";echo$x."s go M".str_repeat($a[0],$n=strlen($e[1])).str_repeat("o",$n).$a[1]."\n";

(सही आउटपुट और 151 बाइट्स)।

— केनी

बिल्लियाँ मेव जाती हैं, गायें मू जाती हैं

चुनौती

रेटिना , 57 49 44 43 41 बाइट्स

व्याख्या

लैबव्यू, 58 लैबव्यूड प्राइमेटिव

पायथ, 50 44 34

पर्ल, 66 61 55 54 बाइट्स

टूट - फूट

पुराना वर्जन:

उदाहरण: Caaat

पायथन 2, 74 बाइट्स

CJam ( 60 57 55 53 बाइट्स)

पॉवरशेल, 135 132 बाइट्स

PHP, 172

स्विफ्ट 2, 3ift8̶1̶ 333 बाइट्स

MATLAB: 190 152 118 बाइट्स

PHP, 138 बाइट्स

OCTAVE, 126 , 108

जावास्क्रिप्ट (ES2015), 78 77

लूआ, 121 90 बाइट्स

लुआ: 115 92 89 बाइट्स

डार्ट , 114 112 110 104 102 100 बाइट्स

PHP, 170 164 161 157 बाइट्स

उदाहरण: `Caaat`