16

अपनी चुनी हुई भाषा में एक फ़ंक्शन बनाएँ जो निम्नलिखित प्रिंट करता है:

Old MacDonald had a farm, E-I-E-I-O,
And on that farm he had a cow, E-I-E-I-O,
With a moo moo here and a moo moo there,
Here a moo, there a moo, everywhere a moo moo,
Old MacDonald had a farm, E-I-E-I-O!

कहाँ cowऔर mooसमारोह मापदंडों में तार हैं, और इस तरह, उदाहरण के लिए pigऔर oinkया sheepऔर baa, में बदला जा सकता है ।

इसे बड़े अक्षरों, हाइफ़न, विराम चिह्न, रिक्त स्थान और लाइन ब्रेक को ध्यान में रखना चाहिए।

अपने कोड में यूनिकोड वर्णों की सबसे कम मात्रा टाइप करने का लक्ष्य रखें।

code-golf kolmogorov-complexity function

— rybo111
स्रोत

1

हालांकि यह kolmogorov-जटिलता नहीं होना चाहिए ?

— मईनीप

6

आप कहते हैं echoes the following। क्या आपका मतलब है कि फ़ंक्शन को इसे प्रिंट करना चाहिए या इसे वापस करना चाहिए?

— cjfaure

2

इस निष्पक्ष को बनाने के लिए, मुझे लगता है कि इस प्रश्न में सटीक विराम चिह्न, रिक्त स्थान और गाड़ी का रिटर्न होना चाहिए। लेकिन आप अपरकेस / लोअरकेस के बारे में क्या सोचते हैं? मैंने सोचा कि एक भी मामला आसान हो सकता है और बेस 64 या इसी तरह के मानक अनुप्रयोगों के भार से बच सकता है। संतुलन पर, एकमात्र राजधानियां लाइन की शुरुआत में, मैकडॉनल्ड शब्द और ईआईईआईओ में हैं, इसलिए यह प्रश्न के अनुसार बिल्कुल दिलचस्प हो सकता है।

— लेवल रिवर सेंट

4

क्या यह आउटपुट के लिए स्वीकार्य है a oinkया होना चाहिए an oink?

— क्लिक करें

4

@ rybo111: क्या आप जानते हैं कि महान डोनाल्ड नुथ ने इस तरह की चीज़ के बारे में एक अकादमिक पत्र लिखा था? यह वास्तव में एक वास्तविक पत्रिका (अप्रैल के संस्करण में सम्मिलित रूप से) में प्रकाशित हुआ था। अधिक यहाँ कागज के पीडीएफ के लिए एक कड़ी सहित: en.wikipedia.org/wiki/The_Complexity_of_Songs

— टॉम Chanler

15

जावास्क्रिप्ट ईएस 6 - 204

अपने कोड में यूनिकोड वर्णों की सबसे कम मात्रा टाइप करने का लक्ष्य रखें ।

कम नहीं, लेकिन शायद सबसे ज्यादा मोटे हैं।

f=(a,b)=>{for(c=[b,a].concat('!,-ADEHIMOWacdefhilmnortvwy \n'.split(o='')),i=62;i;o+=c[e>>10]+c[e/32&31]+c[e&31])e='ⱞᄤ⒇瓤抣瘭㾭癍㚏᫶⦮函࿋Π疽䌐獲樘ྰ㞠戝晐}疽䌐࿈䌐眲Π疽㛏戝癐Π疽伲࿌⒋ფᲉѽ疽䦯䨝抽瘭䦹容㾷碶ᅣᲉᄤྦྷ㜕㞱㗽㾲妴㣗畍⺏'.charCodeAt(--i);alert(o)}

यदि आपका ब्राउज़र ES6 का समर्थन नहीं करता है:

function f(a,b){for(c=[b,a].concat('!,-ADEHIMOWacdefhilmnortvwy \n'.split(o='')),i=62;i;o+=c[e>>10]+c[e/32&31]+c[e&31])e='ⱞᄤ⒇瓤抣瘭㾭癍㚏᫶⦮函࿋Π疽䌐獲樘ྰ㞠戝晐}疽䌐࿈䌐眲Π疽㛏戝癐Π疽伲࿌⒋ფᲉѽ疽䦯䨝抽瘭䦹容㾷碶ᅣᲉᄤྦྷ㜕㞱㗽㾲妴㣗畍⺏'.charCodeAt(--i);alert(o)}

उस कोड को अपने ब्राउज़र कंसोल में कॉपी और पेस्ट करें f('cow','moo'), और कोशिश करें f('pig','oink'),f('sheep','baa')

यह काम किस प्रकार करता है ?

c29 अक्षरों की एक सरणी है और साथ ही जानवर और उसकी ध्वनि (इसे हमारी वर्णमाला कहते हैं )।
तो, सभी 31 वर्ण 5 बिट्स (2 ^ 5 = 32) में फिट होते हैं।
एक यूनिकोड वर्ण 16 बिट लंबा है, इसलिए यह हमारे वर्णमाला के 3 वर्णों को पैडिंग बिट के साथ एन्कोड कर सकता है ।
नई पंक्तियों के साथ पूर्ण पाठ हमारे वर्णमाला के 186 अक्षर हैं , इसे 62 यूनिकोड वर्णों के साथ एन्कोड किया जा सकता है।

उदाहरण के लिए, Oldइस तरह एन्कोड किया गया है:

alphabet value         O      l      d
alphabet index         11     20     15
unicode           0  01011  10100  01111  ===> \u2e8f (⺏)

यदि आपको कुछ यूनिकोड चार्ट पढ़ने में परेशानी हो रही है, तो Code2000 फ़ॉन्ट स्थापित करें

— माइकल एम।
स्रोत

2

"cow"और "moo"फ़ंक्शन पैरामीटर माना जाता है। किसी सरणी को पास करने के लिए कॉलर प्राप्त करके, आप कॉलिंग कोड के वर्ण गणना में जोड़ने की कीमत पर फ़ंक्शन परिभाषा के भीतर पात्रों को बचा रहे हैं। यह मेरे लिए एक धोखा की तरह बदबू आ रही है। उस दृष्टिकोण को चरम पर ले जाते हुए आप function f(a){alert(a)}(23 वर्णों) को परिभाषित कर सकते हैं और कह सकते हैं कि इसे पसंद करने की आवश्यकता है f("Old MacDonald had a ...")।

— tobyink

1

मैंने स्ट्रिंग्स को दो अलग-अलग मापदंडों में पारित किया था, लेकिन चुनौती को पढ़ने के बाद, मैंने अरेंज फॉर्मेट में स्ट्रिंग्स पास नहीं करने का कोई कारण नहीं देखा, इसलिए मैंने अपना उत्तर संपादित किया। यह धोखा नहीं है, बस जब संभव हो तो कुछ वर्णों को बचा रहा है। चलो @ rybo111 तय करते हैं कि यह नियम फिट बैठता है या नहीं।

— माइकल एम।

1

@tobyink मैंने नियमों में 'string' (एरे) शब्द का इस्तेमाल किया है, इसलिए मुझे लगता है कि आप सही हैं। मुझे लगता है कि 'धोखा' थोड़ा कठोर है, हालांकि!

— rybo111

2

इसके पास इतने वोट क्यों हैं? यह 200 से अधिक है और सबसे छोटा जावास्क्रिप्ट समाधान भी नहीं है।

— aditsu छोड़ दिया क्योंकि एसई EVIL

Whell Yougth और अच्छी तरह से समझाया तो मेरा वोट भी है

— edc65

5

सीजाम - 142 / गोल्फस्क्रिप्ट - 144

{" had| a |farm|68, |68 8|here|Old MacDonald765|, E-I-E-I-O|10,
And on that 5 he7690,
With3 2 and3 t2,
Here4t24everyw23,
10!"'|/~A,{`/\*}/}:F;

के "cow""moo"F
लिए : GolfScript के '|साथ "|"और Aसाथ बदलें10

स्पष्टीकरण:

प्रमुख हिस्सा है A,{`/\*}/:
A,{...}/0 से 9 तक प्रत्येक संख्या के लिए ब्लॉक निष्पादित करता है (ए = 10)
` संख्या को स्ट्रिंग में परिवर्तित
/\*करता है एक स्ट्रिंग को प्रतिस्थापित करता है: यदि हमारे पास स्टैक है "bar" "foo 1 baz" "1"तो /स्ट्रिंग को विभाजित करता है ["foo " " baz"], जिसके परिणामस्वरूप \पिछले आइटम के साथ इस सरणी को स्वैप करता है ("बार") और *परिणामस्वरूप सरणी को जोड़ता है"foo bar baz"

इसलिए कोड प्रत्येक नंबर को मुख्य स्ट्रिंग में एक स्ट्रिंग के साथ बदलता है जो पहले स्टैक पर है। हमारे पास जानवर और ध्वनि है, फिर "था", "ए", आदि और अंत में ", ईआईईआईओ" और मुख्य स्ट्रिंग, "10, ...!"। बहुत सारे उद्धरणों का उपयोग करने से बचने के लिए, मैंने सभी स्ट्रिंग (मापदंडों को छोड़कर) को एक स्ट्रिंग में डाल दिया, फिर इसे विभाजित किया और परिणामी सरणी ( '|/~) में फेंक दिया।

मुख्य स्ट्रिंग निम्नलिखित परिवर्तनों से गुजरती है:

10,
And on that 5 he7690,
With3 2 and3 t2,
Here4t24everyw23,
10!

बदलने के "0" साथ", E-I-E-I-O" :

1, E-I-E-I-O,
And on that 5 he769, E-I-E-I-O,
With3 2 and3 t2,
Here4t24everyw23,
1, E-I-E-I-O!

बदलने के "1" साथ"Old MacDonald765" :

Old MacDonald765, E-I-E-I-O,
And on that 5 he769, E-I-E-I-O,
With3 2 and3 t2,
Here4t24everyw23,
Old MacDonald765, E-I-E-I-O!

बदलने के "2" साथ"here" , फिर आदि के "3"साथ "68 8"।

8 ध्वनि से मेल खाती है, और 9 जानवर के लिए।

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत

क्या आप इसे समझा सकते हैं? मुझे यह भी नहीं पता कि सीजेएम क्या है

— क्रंचर

@ क्रंचर सीजाम एक ऐसी भाषा है जिसे मैंने बनाया, sf.net/p/cjam ; मैं इसे समझा सकता हूं एक बार जब मैं इसे गोल्फ खत्म कर लेता हूं :)

— एडिट्स ने छोड़ दिया क्योंकि एसई EVIL

1

@ क्रंचर ने अब स्पष्टीकरण

— दिया

9

♬ और उस पांच पर उसने छह नौ, ze eee ro

— ad

कर सकते हैं E-I-एक स्ट्रिंग जो तब दोहराया है हो सकता है? :)

— rybo111

5

बैश + आइकनव, 128 यूनिकोड वर्ण

नीचे दिए गए शुद्ध-बैश / एससीआई फ़ंक्शन बॉडी और रिवर्स-एनकोड को यूनिकोड वर्ण में ले जाता है:

m()(c=`iconv -t unicode<<<㵳⁜屡␠ਲ㵨敨敲攊ⰽ⁜ⵅⵉⵅⵉ੏㵯伢摬䴠捡潄慮摬栠摡愠映牡⑭≥攊档⁯␢Ɐ䄊摮漠⁮桴瑡映牡⁭敨栠摡愠␠␱ⱥ圊瑩⑨⁳㈤␠⁨湡⑤⁳㈤琠栤ਬ效敲猤‬⑴⑨ⱳ攠敶祲⑷⑨⁳㈤ਬ漤™ਠ`
eval "${c:2}")

एक शेल फ़ंक्शन को परिभाषित करता है m। इस रूप में कॉल करें:

$ एम टट्टू प्रतिद्वंद्वी
ओल्ड मैकडोनाल्ड के पास एक खेत था, EIEIO,
और उस खेत पर उसने एक टट्टू, EIEIO,
यहां एक प्रतिद्वंद्वी प्रतिद्वंद्वी के साथ और एक प्रतिद्वंद्वी प्रतिद्वंद्वी के साथ,
यहां एक प्रतिद्वंद्वी, एक प्रतिद्वंद्वी, हर जगह एक प्रतिद्वंद्वी प्रतिद्वंद्वी,
ओल्ड मैकडोनाल्ड के पास एक खेत था, EIEIO!
$

शुद्ध बैश, 171 बाइट्स (एससीआईआई केवल)

मुझे लगता है कि यह ध्यान देने योग्य है कि मूल कविता ("गाय" और "मू") केवल 203 वर्ण है।

m()(s=\ a\ $2
h=here
e=,\ E-I-E-I-O
o="Old MacDonald had a farm$e"
echo "$o,
And on that farm he had a $1$e,
With$s $2 $h and$s $2 t$h,
Here$s, t$h$s, everyw$h$s $2,
$o"!)

शेल फ़ंक्शन को परिभाषित करता है m। इस रूप में कॉल करें:

$ एम भेड़ बा
ओल्ड मैकडोनाल्ड के पास एक खेत था, EIEIO,
और उस खेत में उसकी एक भेड़ थी, EIEIO,
यहाँ एक baa baa और वहाँ baa baa के साथ,
यहाँ एक बा, वहाँ एक बा, हर जगह एक बा,
ओल्ड मैकडोनाल्ड के पास एक खेत था, EIEIO!
$

— डिजिटल आघात
स्रोत

4

C ++ (403)

ठीक है, यह एक लंबा शॉट है, लेकिन ओवर-डिफाइनिंग किसे पसंद नहीं है?

#define O ", E-I-E-I-O"
#define E O<<","
#define I "Old MacDonald had a farm"
#define H(a) "And on that farm he had a "<<a<<E
#define D(s) s<<" "<<s
#define W(s) "With a "<<D(s)<<" here and a "<<D(s)<<" there,"
#define V(s) "Here a "<<s<<", there a "<<s<<", everywhere a "<<D(s)<<","
#define F I<<O<<"!"
#define N endl
void m(string a, string s){cout<<I<<E<<N<<H(a)<<N<<W(s)<<N<<V(s)<<N<<F<<N;}

— einsteinsci
स्रोत

2

this.eyes.bleeding = सत्य;

— प्रॉक्सी

कोई भी परिभाषित जो आगे इस तंग पैक कर सकता है?

— आइंस्टीनसी

1

यह #define X defineतब संभव हुआ करता था और तब उपयोग होता था #X Y Z। अफसोस की बात है, उन मादक IOCCC दिनों अब लंबे समय से कर रहे हैं ...

— nneonneo

के +बजाय का उपयोग करने के बारे में क्या <<? या char*इसके बजाय का उपयोग कर string? // इनमें से केवल एक ही समय में इस्तेमाल किया जा सकता है।

— क्वर्टी २५'१४

2

अजगर, 116 यूनिकोड वर्ण

def f(**a):print u'鱸쿳光䷰癌쿉ы㊲匒ሔ툕謒畲尔㵵䅵忘쮇⼱ⅅ伿⒡넣Ⰴ邩ઑ꩕醪徜妮ꊌ㰺⒳Ⰳ鮕꾟ౙ㎧譒ᕒ끒镈롴쀼怪㪢愐腤닔ꋔ狊兔Ⲹ㾗꽡Ȩ똀䝸å'.encode('u16')[2:].decode('zip')%a

StackOverflow मेरे विशेष पात्रों को खा रहा है, हालाँकि, यहाँ बेस 64 में फाइल है:

77u/ZGVmIGYoKiphKTpwcmludCB1J+mxuOy/s+WFieS3sOeZjOy/idGL44qy5YyS4YiU7YiV6KyS55Wy5bCU47W15IW15b+Y7K6H4ryx4oWF5Ly/4pKh64Sj4rCE6YKp4KqR6qmV6Yaq5b6c5aau6oqM47C64pKz4rCD6a6V6r6f4LGZ446n6K2S4ZWS74yS64GS6ZWI7pKA66G07IC85oCq46qi5oSQ6IWk64uU6ouU54uK5YWU4rK4476X6r2hyKjrmIDknbjDpScuZW5jb2RlKCd1MTYnKVsyOl0uZGVjb2RlKCd6aXAnKSVh

डेटा को zlib का उपयोग करके पैक किया जाता है, जो कुशलता से बार-बार तार कोड करता है (zlib सामान्य रूप से पाठ को संपीड़ित करने में अच्छा है)। "यूनिकोड वर्ण" नियम का लाभ उठाने के लिए, 121-बाइट ज़ालिब चंक को यूटीएफ -16 के रूप में बाईट्रेस्ट्रिंग की व्याख्या करके 61-कैरेक्टर यूनिकोड स्ट्रिंग में गद्देदार और आधा किया जाता है।

फ़ंक्शन को कॉल करें

f(cow='pig', moo='oink')

— nneonneo
स्रोत

अच्छा है, लेकिन जहां गाय और मूव फंक्शन मापदंडों में तार होते हैं, और जैसे, सुअर और oink या भेड़ और बा के लिए बदला जा सकता है, उदाहरण के लिए । ऐसा लगता है कि आपका आउटपुट गाय / मू तक हार्डकोडेड है।

— डिजिटल ट्रामा

@DigitalTrauma: मेरी पढ़ने की समझ विफल! फिक्स्ड।

— nnonneo

बेहतर :) :)

— डिजिटल ट्रॉमा

115 । अनुगामी न्यूलाइन को गिनने की आवश्यकता नहीं है।

— २१

@ nyuszika7h नहीं, यह 116 है। आप शुरुआत में "UTF-8 BOM" (EF BB BF) को गिनना भूल गए, जो कि Python 2 को गैर-ASCII स्रोत को स्वीकार करने के लिए आवश्यक है। (यह पायथन 3 नहीं है, जो नहीं है .decode('zip')।)

— एंडर्स कासोर्ग

1

पायथन, 217

तुम सच में इतना गोल्फ नहीं कर सकते। मैं सिर्फ सामने के दोहराव को हटा दिया और ...

m,f="Old MacDonald had a farm, E-I-E-I-O",lambda x,y:m+",\nAnd on that farm he had a %s, E-I-E-I-O,\nWith a %shere and a %sthere,\nHere a %s, there a %s, everywhere a %s %s,\n%s!"%((x,)+((y+' ')*2,)*2+(y,)*4+(m,))

जावास्क्रिप्ट, 241 - JSCrush धोखा

JSCrush के साथ इसे बनाया गया ... वास्तव में वास्तविक उत्तर नहीं, यह देखना दिलचस्प होगा कि क्या कोई इसे मुख्यधारा की भाषा में हरा सकता है। ( संपादित करें : उह)

_='var f=function(c,a){var b=a "+a;return"Anon that he hadcWith  and tHere  t   everyw!"};OlMacDonalhaa a "+, O,\\nhere+"b farm a, d E-I-';for(Y in $=' ')with(_.split($[Y]))_=join(pop());eval(_)

— cjfaure
स्रोत

1

जावा, 246

void f(String[] a){String o="Old MacDonald had a farm",e=", E-I-E-I-O",x=" a "+a[1],s=x+" "+a[1];System.out.print(o+e+",\nAnd on that farm he had a "+a[0]+e+",\nWith"+s+" here and"+s+" there,\nHere"+x+", there"+x+", everywhere"+s+",\n"+o+e+"!");}

उपयोग: f(new String[]{"cow","moo"});

— Gayuha
स्रोत

1

जावा - २६२ २५ 258

void m(String...s){String b=s[1],c=b+" "+b,d="E-I-E-I-O",e="Old MacDonald had a farm, "+d;System.out.print(e+",\n"+"And on that farm he had a "+s[0]+", "+d+",\nWith a "+c+" here and a "+c+" there,\nHere a "+b+", there a "+b+", everywhere a "+c+",\n"+e+"!");}

आगे अनुकूलन निश्चित रूप से संभव है।

— Ypnypn
स्रोत

आप

— प्रिंटफ का

ट्रेविन एवरी ने इस संपादन का सुझाव दिया: जावा - 243 - शून्य स्ट्रिंग ... a) {स्ट्रिंग c = "a + + a [1], d = c +" "+ a [1], e =", EIEIO ", f = "ओल्ड मैकडोनाल्ड के पास एक खेत था" + e; System.out.print (f + ", \ n और उस खेत पर उसका" + + a [0] + e + ", \ n" + d + "यहाँ और" + d + "था। , \ nHere "+ c +", वहाँ "+ c +", हर जगह "+ d +", \ n "+ f +"! ");} आगे अनुकूलन निश्चित रूप से संभव है

— जस्टिन

1

पर्ल 5 (UTF-8) - 131 वर्ण, 313 बाइट्स

नीचे दी गई स्क्रिप्ट को बिना BOM वाले UTF-8 के रूप में सहेजने की आवश्यकता है।

use utf8;use Encode;eval encode ucs2,'獵戠晻③㴤∮灯瀻⑥㴢Ⱐ䔭䤭䔭䤭伢㬤漽≏汤⁍慣䑯湡汤⁨慤⁡⁦慲洤攢㬤ⰽ≥牥⁡∻獡礢⑯Ⰺ䅮搠潮⁴桡琠晡牭⁨攠桡搠愠䁟⑥Ⰺ坩瑨⁡③③⁨␬湤⁡③③⁴桥牥Ⰺ䠤Ⱔ戬⁴栤Ⱔ戬⁥癥特睨␬③③Ⰺ⑯™紱';

उपयोग: f("cow", "moo");।

पर्ल को -M5.0105.l सुविधाओं को सक्षम करने के लिए ध्वज के साथ चलना चाहिए था । ( इसकी अनुमति है ।)

मुझे कैरेक्टर काउंट (131) और बाइट काउंट (313) की समरूपता पसंद है। यह बहुत यिन और यांग है।

पर्ल 5 (ASCII) - 181 वर्ण, 181 बाइट्स

sub f{$b=$".pop;$e=", E-I-E-I-O";$o="Old MacDonald had a farm$e";$,="ere a";say"$o,
And on that farm he had a @_$e,
With a$b$b h$,nd a$b$b there,
H$,$b, th$,$b, everywh$,$b$b,
$o!"}

उपयोग: f("cow", "moo");।

फिर से, -M5.010पर्ल को 5.l सुविधाओं को सक्षम करने के लिए ध्वज के साथ चलने की आवश्यकता है।

— tobyink
स्रोत

हम्म, फैमिली कोडगुल्फ़.स्टैकएक्सचेंज.com/a/26633/11259 ;-)

— डिजिटल ट्रॉमा

वास्तव में codegolf.stackexchange.com/a/26628/12469 मेरा शुरुआती बिंदु था। मैंने कुछ अतिरिक्त चरों का परीक्षण किया जो आगे की लंबाई को काटते हैं, और फिर UTF16 ट्रिक को लागू करते हैं जो कि कई अन्य कार्यान्वयन का उपयोग करते हैं।

— tobyink

1

सीजेएम (गैर-एएससीआईआई) - 77 चार्ट

"啝裢樃濿䶹讄團챤鋚䖧雿ꆪꆵ䷶텸紎腕Խꍰ搓᩟童䚯⤭刧损⬛豳Ẍ퍾퓱郦퉰怈䡞௳閶蚇⡾쇛蕟猲禼࿆艹蹚㞿䛴麅鞑椢⧨餎쏡첦휽嬴힡ݷ녣㯂鐸㭕"56e3b127b:c~

उपयोग: "cow""moo"F

स्ट्रिंग मेरा दूसरा CJam सॉल्यूशन है जो 127 से बेस 56000 में बदल गया है।
UTF-8 लोकेल की आवश्यकता हो सकती है।

वैसे, अब आप http://cjam.aditsu.net/ पर इसे ऑनलाइन आज़मा सकते हैं

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत

1

जावास्क्रिप्ट: 152 चार्ट / ईएस 6: 149 चार्ट

यहाँ "z" नामक JS फ़ंक्शन है जो 214 वर्णों में कार्य करता है। (इसे निष्पादित न करें!)

function z(a,b){c=' a '+b;d=c+' '+b;e=', E-I-E-I-O';f='Old MacDonald had a farm'+e;return(f+',\nAnd on that farm he had a '+a+e+',\nWith'+d+' here and'+d+' there,\nHere'+c+', there'+c+', everywhere'+d+',\n'+f+'!')}

मैंने @subzey और I द्वारा 140byt.es के लिए बनाई गई तकनीक का उपयोग करके इसे यूनिकोड वर्णों में "पैक" किया है।

eval(unescape(escape('𩡵𫡣𭁩𫱮𘁺𚁡𛁢𚑻𨰽𙰠𨐠𙰫𨠻𩀽𨰫𙰠𙰫𨠻𩐽𙰬𘁅𛑉𛑅𛑉𛑏𙰻𩠽𙱏𫁤𘁍𨑣𡁯𫡡𫁤𘁨𨑤𘁡𘁦𨑲𫐧𚱥𞱲𩑴𭑲𫠨𩠫𙰬𧁮𠑮𩀠𫱮𘁴𪁡𭀠𩡡𬡭𘁨𩐠𪁡𩀠𨐠𙰫𨐫𩐫𙰬𧁮𥱩𭁨𙰫𩀫𙰠𪁥𬡥𘁡𫡤𙰫𩀫𙰠𭁨𩑲𩐬𧁮𢁥𬡥𙰫𨰫𙰬𘁴𪁥𬡥𙰫𨰫𙰬𘁥𭡥𬡹𭱨𩑲𩐧𚱤𚰧𛁜𫠧𚱦𚰧𘐧𚑽').replace(/uD./g,'')))

अंतिम स्निपेट निष्पादित करें, फिर कॉल करें z("cow","moo"), और आपको यह स्ट्रिंग मिल जाएगी:

Old MacDonald had a farm, E-I-E-I-O,
And on that farm he had a cow, E-I-E-I-O
With a moo moo here and a moo moo there,
Here a moo, there a moo, everywhere a moo moo,
Old MacDonald had a farm, E-I-E-I-O!"

अधिक जानकारी यहाँ: http://xem.github.io/golfing/en.html#compress

ES6 संस्करण:

eval(unescape(escape('𮠽𚁡𛁢𚐽🡻𨰽𙰠𨐠𙰫𨠻𩀽𨰫𙰠𙰫𨠻𩐽𙰬𘁅𛑉𛑅𛑉𛑏𙰻𩠽𙱏𫁤𘁍𨑣𡁯𫡡𫁤𘁨𨑤𘁡𘁦𨑲𫐧𚱥𞱲𩑴𭑲𫠨𩠫𙰬𧁮𠑮𩀠𫱮𘁴𪁡𭀠𩡡𬡭𘁨𩐠𪁡𩀠𨐠𙰫𨐫𩐫𙰬𧁮𥱩𭁨𙰫𩀫𙰠𪁥𬡥𘁡𫡤𙰫𩀫𙰠𭁨𩑲𩐬𧁮𢁥𬡥𙰫𨰫𙰬𘁴𪁥𬡥𙰫𨰫𙰬𘁥𭡥𬡹𭱨𩑲𩐧𚱤𚰧𛁜𫠧𚱦𚰧𘐧𚑽').replace(/uD./g,'')))

— XEM
स्रोत

मुझे लगता है कि आपने चीजों को सही तरीके से कॉपी-पेस्ट नहीं किया है, ऐसा लगता है कि आपके कोड में 250 से अधिक वर्ण हैं - उफ़, शायद नहीं, लेकिन मेरा पाठ संपादक अजीब व्यवहार कर रहा है, मैं जांच करूँगा।

— एडित्सू ने छोड़ दिया क्योंकि एसई ईवीआईएल

ओह, आपके अधिकांश चरित्र कुछ सूक्ष्म विमानों से हैं (शायद इसीलिए उन्हें यहां 2 वर्णों के रूप में गिना जाता है) ... और असंबद्ध भी। यह नियमों को थोड़ा

— बढ़ा रहा है

खैर, मुझे नहीं लगता कि यह धोखा है: उन प्रतीकों में यूनिकोड वर्ण हैं, और उन्हें 2 वर्णों के रूप में नहीं गिना जाना चाहिए। इसके अलावा, ट्विटर उनमें से प्रत्येक को 1 चार के रूप में गिना जाता है। यदि आप एक ट्वीट में ES6 संस्करण की नकल करते हैं, तो यह कहता है कि यह 9 वर्णों से बहुत लंबा है। तो, 149 यह :) है

— xem

1

सी # - 339 बाइट्स

void x(string c, string d){var a="Old MacDonald had a farm";var b=", E-I-E-I-O";var f=" a ";var g=" there";Debug.WriteLine(a+b+",");Debug.WriteLine("And on that farm he had"+f+c+b+",");Debug.WriteLine("With"+f+d+" "+d+" here and"+f+d+" "+d+g+",");Debug.WriteLine("Here"+f+d+","+g+f+d+", everywhere"+f+d+" "+d+",");Debug.WriteLine(a+b+"!");

उपयोग: x("cow","moo");

— tsavinho
स्रोत

1

प्रतिबल, २०६ २०२

f: func[a b][print reword{$o$e,
And on that farm he had a $a$e,
With a $b $b here and a $b $b there,
Here a $b, there a $b, everywhere a $b $b,
$o$e!}[e", E-I-E-I-O"o"Old MacDonald had a farm"a a b b]]

उपयोग: f "cow" "moo"

— draegtun
स्रोत

0

डेल्फी एक्सई 3 ( 272 252)

procedure k(a,s:string);const o='Old MacDonald had a farm';e=', E-I-E-I-O';n=','#13#10;begin s:=' '+s;write(o+e+n+'And on that farm he had a '+a+e+n+'With a'+s+s+' here and a'+s+s+' there'+n+'Here a'+s+', there a'+s+' every where a'+s+s+n+o+e+'!');end;

Ungolfed

procedure k(a,s:string);
const
  o='Old MacDonald had a farm';
  e=', E-I-E-I-O';
  n=','#13#10;
begin
  s:=' '+s;
  write(o+e+n+'And on that farm he had a '+a+e+n+'With a'+s+s+' here and a'+s+s+' there'+n+'Here a'+s+', there a'+s+' every where a'+s+s+n+o+e+'!');
end;

— तेण प्रुन
स्रोत

0

लुआ 237

function f(a,b)c=b.." "..b;d="Old MacDonald had a farm, E-I-E-I-O"print(d..",\nAnd on that farm he had a "..a..", E-I-E-I-O,\nWith a "..c.." here and a "..c.." there,\nHere a "..b..", there a "..b..", everywhere a "..c..",\n"..d.."!")end

परिभाषित करके c=b.." "..b, मैं एक दर्जन पात्रों को बचा सकता हूं। dजैसा कि मैं करता हूं, परिभाषित करके मैं 23 पात्रों को बचाता हूं। मैं यह नहीं देखता कि मैं इसे कैसे छोटा कर सकता हूं। इसके माध्यम से कहा जाता है f("<animal>","<sound>")।

— काइल कानोस
स्रोत

0

जावा 8 (411)

String m(String...m){LinkedHashMap<String,String>n=new LinkedHashMap<>();n.put("/","( * #, -");n.put("#","farm");n.put("-","E-I-E-I-O");n.put("+","here");n.put("*","had a");n.put("(","Old MacDonald");n.put("|"," a )");n.put(")","moo");n.put("moo",m[1]);n.put("cow",m[0]);m[0]="/,\nAnd on that # he * cow, -,\nWith|) + and|) t+,\nHere|, t+|, everyw+|),\n/!";n.forEach((k,v)->m[0]=m[0].replace(k,v));return m[0];}

लैम्ब्डा का दुरुपयोग, एक परिभाषित क्रम में उन्हें रखने के लिए एक लिंक्डशप में रिप्लेसमेंट किया, फिर मुख्य स्ट्रिंग में मूल्य के साथ कुंजी को बदलने के लिए एक फ़ॉरेस्ट लैम्ब्डा का उपयोग किया। नक्शे में अंतिम 2 प्रतिस्थापन के रूप में पैरामीटर जोड़े जाते हैं। वैरगेज तर्क विधि हेडर में कुछ बाइट्स को दाढ़ी बनाने के लिए है

Ungolfed संस्करण:

String m(String... m)
{
    LinkedHashMap<String, String> n = new LinkedHashMap<>();
    n.put("/", "( * #, -");
    n.put("#", "farm");
    n.put("-", "E-I-E-I-O");
    n.put("+", "here");
    n.put("*", "had a");
    n.put("(", "Old MacDonald");
    n.put("|", " a )");
    n.put(")", "moo");
    n.put("moo", m[1]);
    n.put("cow", m[0]);
    m[0] = "/,\nAnd on that # he * cow, -,\nWith|) + and|) t+,\nHere|, t+|, everyw+|),\n/!";
    n.forEach((k, v) -> m[0] = m[0].replace(k, v));
    return m[0];
}

— masterX244
स्रोत

0

जावास्क्रिप्ट 220

function f(a,b){c=' a '+b;d=c+' '+b;e=', E-I-E-I-O';f='Old MacDonald had a farm'+e;console.log(f+',\nAnd on that farm he had a '+a+e+',\nWith'+d+' here and'+d+' there,\nHere'+c+', there'+c+', everywhere'+d+',\n'+f+'!');}

के द्वारा बुलाया गया

f('cow', 'moo');

— ट्रेविन एवरी
स्रोत

0

शुद्ध सी, 298 बाइट्स, कोई यूनिकोड नहीं

अपने फंक्शन में मैं एक एकल तर्क लेता हूं, जो वास्तव में एक char*साथ भरा हुआ है। प्रत्येक स्ट्रिंग को समाप्त कर दिया गया है, और अंत में एक अतिरिक्त शून्य टर्मिनेटर है। यह मुझे जांचने की अनुमति देता हैstrlen(a) एक काउंटर चर रखने के बजाय प्रत्येक लूप के अंत में ।

mcdonald.c:

m(char*a){while(strlen(a)){printf("Old MacDonald had a farm, E-I-E-I-O\nAnd on that farm he had a %s, E-I-E-I-O,\nWith a ",a);a+=strlen(a)+1;printf("%s %s here and a %s %s there,\nHere a %s, there a %s, everywhere a %s %s,\nOld MacDonald had a farm, E-I-E-I-O!\n",a,a,a,a,a,a,a,a);a+=strlen(a)+1;}}

main.c:

int m(char *v);
int main(int argc, char **argv) {
    m("cow\0moo\0programmer\0meh\0\0");
    return 0;
}

आउटपुट:

clang main.c mcdonald.c && ./a.out
Old MacDonald had a farm, E-I-E-I-O
And on that farm he had a cow, E-I-E-I-O,
With a moo moo here and a moo moo there,
Here a moo, there a moo, everywhere a moo moo,
Old MacDonald had a farm, E-I-E-I-O!
Old MacDonald had a farm, E-I-E-I-O
And on that farm he had a programmer, E-I-E-I-O,
With a meh meh here and a meh meh there,
Here a meh, there a meh, everywhere a meh meh,
Old MacDonald had a farm, E-I-E-I-O!

— WJL
स्रोत

0

कोबरा - 203

def f(a,b)
    d=" a [b] "+b
    e=", E-I-E-I-O"
    m="Old MacDonald had a farm[e]"
    print "[m],\nAnd on that farm he had a [a][e],\nWith[d] here and[d] there,\nHere a [b], there a [b], everywhere[d],\n[m]!"

यहां तक कि छोटी-से-बहु-अस्तर वाली भाषा के लिए, और सख्त इंडेंटेशन नियमों के लिए, कोबरा अभी भी बहुत अच्छा करता है।

— Οurous
स्रोत

0

C: 224 बाइट्स

प्रिंटफ प्रिसिजन स्पेसिफ़ायर का उपयोग करके , हम एक ही स्ट्रिंग का उपयोग कर सकते हैं दोनों प्रिंटफ़ प्रारूप स्ट्रिंग और दो मापदंडों के रूप में।

o(char*x,char*y){char*f="Old MacDonald had a farm, E-I-E-I-O,\nAnd on that farm he had a %s%.13sWith a %s %s here and a %s %s there,\nHere a %s, there a %s, everywhere a %s %s,\n%.35s!\n";printf(f,x,f+24,y,y,y,y,y,y,y,y,f);}

सफेद स्थान और स्ट्रिंग के साथ लाइनों में विभाजित:

o(char* x, char* y)
{
    char* f=
        "Old MacDonald had a farm, E-I-E-I-O,\n"
        "And on that farm he had a %s%.13s"
        "With a %s %s here and a %s %s there,\n"
        "Here a %s, there a %s, everywhere a %s %s,\n"
        "%.35s!\n";

    printf(f,x,f+24,y,y,y,y,y,y,y,y,f);
}

— डेविड याव
स्रोत

0

PHP - 272 वर्ण, 272 बाइट्स

function m($q,$w){for($e="@&And on that farm he had^<%&With *h# and*th#&H(th(everywh#^> >&@!",$r=1;;$e=$r){$r=str_replace(["@","#","^","%","<",">","&","*","("],["Old MacDonald had^farm%","ere"," a ",", E-I-E-I-O",$q,$w,",\n","^> > ","#^>, "],$e);if($e==$r)break;}echo $e;}

उपयोग: m("cow", "moo");,m("fox", "Hatee-hatee-hatee-ho");

@#%^<>&*(आउटपुट को क्रैश करने वाले पैरामीटर ।

— नाश्ता
स्रोत

0

हास्केल (282 और अभी भी कुछ पढ़ने योग्य :))

wc -c oldmacdonald.hs
     282 oldmacdonald.hs

फ़ाइल:

main=mapM putStrLn[s"cow""moo",s"pig""oink",s"sheep""baa"]
s c m=o#",\nAnd on that farm he had"#b c#e#let n=m#" "#m in",\nWith"#b n#" here and"#b n#" there,\nHere"#b m#", there"#b m#", everywhere"#b n#",\n"#o#"!\n"
o="Old MacDonald had a farm"#e
e=", E-I-E-I-O"
b=(" a "#)
(#)=(++)

— Linse
स्रोत

यह 281 है, आप आमतौर पर अनुगामी न्यूलाइन की गिनती नहीं करते हैं, जब तक कि यह सी प्रीप्रोसेसर मैक्रो या कुछ और न हो जिसे न्यूलाइन समाप्ति की आवश्यकता होती है। ज्यादातर मामलों में, आप द्वारा दिए गए बाइट काउंट से सिर्फ 1 घटा सकते हैं wc -c, लेकिन मैं mothereff.in/byte-counter का उपयोग करना पसंद करता हूं और यह सुनिश्चित करना चाहता हूं कि कार्यक्रम के काम करने के लिए आवश्यक होने तक अंत में कोई खाली रेखा न हो।

— 21

0

ES6, 179 186 वर्णों के 2 समाधान बिना किसी यूनिकोड के

f=(a,b)=>alert("325And on that farm he had a025With a11 h4nd a11 th45H41, th41, everywh411532!".replace(/\d/g,x=>[" "+a," "+b,", E-I-E-I-O","Old MacDonald had a farm","ere a",",\n"][x]))

और दूसरा:

f=(a,b)=>alert("3625And on7at6 he ha8025With a11 h4n811745H41,741, everywh4115362!".replace(/\d/g,x=>(` ${a}0 ${b}0, E-I-E-I-O0Old MacDonald had a0ere a0,\n0 farm0 th0d a`).split(0)[x]))

मैंने अलर्ट कॉल (+7 वर्ण) जोड़ा है।

— Qwertiy
स्रोत

मुझे लगता है, यह अब तक के लिए गैर-यूनिकोड से सबसे छोटा समाधान है।

— Qwertiy

0

जावास्क्रिप्ट (E6) 140 वर्ण

चार काउंटर: UTm-8 में https://mothereff.in/byte-counter , 140 chars, 425 बाइट्स

eval(unescape(escape('𩠽𚁡𛁢𚐽🡡𫁥𬡴𚀧𜀱𜠵𠑮𩀠𫱮𘀶𨑴𜐳𩐳𨑤𝰠𞐲𝑗𪐶𘁡𞀸𜰴𝱮𩀠𨐸𞀠𝠴𝑈𝀷𞀬𘀶𝀷𞀬𘁥𭡥𬡹𭱨𝀷𞀸𝐰𜐲𘐧𛡲𩑰𫁡𨱥𚀯𧁤𛱧𛁣🐾𚀧𣱬𩀠𣑡𨱄𫱮𨑬𩀠𪁡𩀠𨐰𘁦𨑲𫐰𛀠𡐭𢐭𡐭𢐭𣰰𘁨𜁥𬡥𜀬𧁮𜁴𪀰𘁡𜀠𙰫𨠫𜀫𨐩𛡳𬁬𪑴𚀰𚑛𨱝𚐩𒠠').replace(/uD./g,'')))

मूल ASCII कोड 188 बाइट्स

f=(a,b)=>alert('0125And on 6at13e3ad7 925Wi6 a88347nd a88 645H478, 6478, everywh47885012!'.replace(/\d/g,c=>('Old MacDonald had a0 farm0, E-I-E-I-O0 h0ere0,\n0th0 a0 '+b+0+a).split(0)[c]))

साथ संपीडित http://xem.github.io/obfuscatweet/

FireFox / FireBug कंसोल में टेस्ट करें

f('mosquito','zzz')

उत्पादन

Old MacDonald had a farm, E-I-E-I-O,
And on that farm he had a mosquito, E-I-E-I-O,
With a zzz zzz here and a zzz zzz there,
Here a zzz, there a zzz, everywhere a zzz zzz,
Old MacDonald had a farm, E-I-E-I-O!

— edc65
स्रोत

पुराना मैकडॉनल्ड फ़ंक्शन