55

एक फ़ंक्शन या प्रोग्राम लिखें जो लोकप्रिय अंग्रेजी जीभ-ट्विस्टर के इनपुट और आउटपुट वेरिएंट के रूप में दो शब्द लेता है "अगर एक लकड़ी की लकड़ी लकड़ी को चक सकती है तो लकड़ी की चक कितनी लकड़ी की होगी?"

आउटपुट पहले शब्द का चार बार उपयोग करेगा

अगर कोई चक चक सकता है तो चक चक कितना woodहोगा ?woodwoodwood

और दूसरा शब्द चार बार

chuck chuckअगर एक लकड़ी लकड़ी chuckकर सकती है तो लकड़ी कितनी होगी chuck?

बाकी आउटपुट किसी भी इनपुट के लिए समान हैं।

How muchलकड़ी would aवुडकॉक चक if aवुडचुक couldचक वुड?

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

आदर्श रूप से आपका कोड किसी भी मुद्रण योग्य ASCII वर्ण वाले इनपुट को संभाल लेगा। हालांकि, मुद्रण योग्य ASCII के उचित सबसेट के लिए इनपुट को प्रतिबंधित करने की अनुमति है; बस अपने उत्तर में इसका संकेत दें। बड़े चरित्र सेट को संभालना बेशक ठीक है।

उदाहरण इनपुट-आउटपुट जोड़े:

"wood", "chuck"
"How much wood would a woodchuck chuck if a woodchuck could chuck wood?"

"ground", "hog"
"How much ground would a groundhog hog if a groundhog could hog ground?"

"bar", "keep"
"How much bar would a barkeep keep if a barkeep could keep bar?"

"money", "belt"
"How much money would a moneybelt belt if a moneybelt could belt money?"

"rain", "fall"
"How much rain would a rainfall fall if a rainfall could fall rain?"

"hair", "cut"
"How much hair would a haircut cut if a haircut could cut hair?"

"green", "house"
"How much green would a greenhouse house if a greenhouse could house green?"

"jabber", "wock"
"How much jabber would a jabberwock wock if a jabberwock could wock jabber?"

"pine", "apple"
"How much pine would a pineapple apple if a pineapple could apple pine?"

"Rob", "Lowe"
"How much Rob would a RobLowe Lowe if a RobLowe could Lowe Rob?"

"code", "golf"
"How much code would a codegolf golf if a codegolf could golf code?"

"fish", ""
"How much fish would a fish  if a fish could  fish?"

"", "fish"
"How much  would a fish fish if a fish could fish ?"

"", ""
"How much  would a   if a  could  ?"

"  ", "     "
"How much    would a               if a         could         ?"

"would a", "how much"
"How much would a would a would ahow much how much if a would ahow much could how much would a?"

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट जीतती है। सभी भाषाओं में उत्तर का स्वागत है, भले ही कुछ अन्य भाषाएं इसे कम बाइट्स में कर सकें।

( इस मेम द्वारा प्रेरित , जो इस कठोर पैटर्न से बेहतर एक इनपुट जोड़ी का उपयोग करता है ....)

code-golf string

— ग्रेग मार्टिन
स्रोत

2

क्या हम मान सकते हैं कि दो शब्द दो अलग-अलग शब्द होंगे?

— जोनाथन एलन

4

... मुझे लगता है "", ""कि कोई मतलब नहीं: पी

— जोनाथन एलन

1

@ क्रोनोसाइडल मैं आपको निराश नहीं देख सकता। ....

— ग्रेग मार्टिन

6

दो। यह दो कोड को गोल्फ करेगा।

— user2357112

1

अजी, मैं उम्मीद कर रहा था कि यह एक छोटे कार्यक्रम के बारे में होगा जो अन्य कोड पर कुछ सरल गोल्फ रूपांतरण कर सकता है।

— aschepler

40

पायथन 3 , 70 67 बाइट्स

"How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?".format

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

मेरा मतलब है, अगर जूता फिट बैठता है ..

टाइपो पकड़ने के लिए मैनटवर्क का धन्यवाद

उत्कृष्ट -3 बाइट्स विचार के लिए रेम्को हेज़िंग का धन्यवाद

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

अपडेट: आशीर्वाद मिला, सब अच्छा है :)

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

lambda a,b:f"How much {a} would a {a+b} {b} if a {a+b} could {b} {a}?"

— मोनिका को बहाल करो
स्रोत

2

शायद अप्रासंगिक, लेकिन स्वचालित प्रारूप स्ट्रिंग 3.6 से पहले पायथन संस्करणों में आसानी से उपलब्ध नहीं है

— M.Herzkamp

3

@ M.Herzkamp तो?

— रूहोला

16

@ruohola मुझे लगता है कि M.Herzkamp इस जवाब को शीर्षक कहने की कोशिश कर रहा है कि "पायथन 3" के बजाय "पायथन 3.6" होना चाहिए।

— श्री लिस्टर

8

यहां तक कि छोटे और अजगर 2 संगत (67 बाइट्स) "How much {0} would a {0}{1} {1} if a {1}{0} could {1} {0}?".format:। यह बिना फंसे स्ट्रिंग के लिए एक फ़ंक्शन देता है।

— रेमो हस्ज़िंग

1

मैं कोई पायथन विशेषज्ञ नहीं हूं, लेकिन चूंकि print("How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?".format("wood","chuck"))वांछित उत्पादन उत्पन्न करता है, इसलिए मुझे इसे स्वीकार करने का कोई कारण नहीं दिखता है :)

— ग्रेग मार्टिन

25

टी-एसक्यूएल, 82 बाइट्स

SELECT'How much '+w+' would a '+w+c+' '+c+' if a '+w+c+' could '+c+' '+w+'?'FROM t

इनपुट पूर्व मौजूदा तालिका से लिया जाता है कॉलम के साथ और , हमारे आईओ नियमों के अनुसार । $t$ $w$ $c$

एक बाइट लंबे समय तक, लेकिन किसी कारण के लिए थोड़ा और मनभावन:

SELECT REPLACE(REPLACE('How much 1 would a 12 2 if a 12 could 2 1?',1,w),2,c)FROM t

यह संस्करण इनपुट के सबसेट पर काम करता है जिसमें पहले शब्द में अंक शामिल नहीं है ।2 $w$

क्योंकि मैं SQL में हूं, मैं सभी उदाहरणों को तालिका में पहले से लोड कर सकता हूं, और उन सभी को एक साथ चला सकता हूं:

— BradC
स्रोत

2

+1000000 वर्चुअल ट्रेन मेगाट्रेन के लिए

— ग्रेग मार्टिन

5

मुझे लगता है कि "डब्ल्यू" और "सी" क्रमशः "लकड़ी" और "चक" के लिए खड़े हैं: पी

— user253751

यह Oracle में 67 बाइट्स में किया जा सकता है जैसा कि SQL * प्लस (कोई तालिका नहीं) से कहा जाता है:select'How much &1 would a &1&2 &2 if a &1&2 could &2 &1?'from dual

— बेन

16

बैश , 50 बाइट्स

echo How much $2 {would,$1\ if}\ a\ $2$1 could $@?

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

-5 बाइट्स नीचे टिप्पणी से मदद के कारण।

— spuck
स्रोत

-3 बाइट्स

— ग्रैमी

1

-2 बाइट्स अधिक

— नहुएल फौलीउल

1

नाहुएल के गोल्फ को निहारते समय आपने एक अनावश्यक बैकलैश जोड़ा। यहाँ 53 है । (हालांकि वास्तव में यह 50 होना चाहिए, कुछ भी $ 2 के रूप में पहला शब्द और $ 1 के रूप में दूसरा शब्द लेने से आप बंद हो जाता है।)

— ग्रिमी

2

@Grimy: मैं मूल पोस्टर से चुनौती पर टिप्पणी देख रहा हूं जो मापदंडों को उलटने की अनुमति देता है। मैं 50 बाइट्स के उत्कृष्ट उत्तर के उत्तर को अपडेट कर रहा हूं। धन्यवाद!

— spuck

1

@roblogic: बैकस्लैश रिक्त स्थान पर शब्द विभाजन से बचने के लिए रिक्त स्थान को उद्धृत करते हैं, और घुंघराले ब्रेसिज़ को दो शब्दों के रूप में दो बार विस्तारित किया जाता है, एक बार ब्रेसिज़ के अंदर प्रत्येक स्ट्रिंग के साथ, और वे अक्षर जो ब्रेसिज़ का निशान लगाते हैं (लेकिन शब्द का हिस्सा) प्रत्येक स्ट्रिंग के अंत में जोड़े जाते हैं। शब्द को विभाजित करने में मदद करने के लिए वर्गाकार ब्रेसिज़ जोड़ना: "[a {bc, de} f]" दो शब्द बन जाते हैं: "[abcf] [adef]"। तो "[{$ 1 \ अगर होता} \ एक \ $ 2 $ 1]" हो जाता है "[\ होगा एक \ $ 2 $ 1] [$ 1 \ यदि \ एक \ $ 2 $ 1]"

— spuck

15

स्टैक्स , 33 31 30 29 बाइट्स

-1 पुनरावर्ती के लिए धन्यवाद !

¢èO∩sP↑å♥|1╧ì}ò♂xb■δå«█Γ╨╦►Q²

भागो और इसे staxlang.xyz पर डीबग करें!

प्रत्येक घटक को रिवर्स ऑर्डर में स्टैक में पुश करें, फिर सभी रिक्त स्थान के साथ जुड़ें।

अनपैक्ड (35 बाइट्स) और स्पष्टीकरण:

X'?+;`IM'`x;+Y`~^$`,y`75\`x`Q)("`LJ
X                                      Set register X to the first word
                                       "wood"
 '?+                                   Append a question mark, popping from the input stack
                                       "wood?"
    ;                                  Peek from input stack and push to main stack
                                       "chuck" "wood?"
     `IM'`                             Literal "could"
                                       "could" "chuck" "wood?"
          x;+Y                         Peek register x. Peek input. Concatenate. Set register Y.
                                       "woodchuck" "could" "chuck" "wood?"
              et cetera, ad nauseam
                                  LJ   Listify the stack and join with spaces
                                       Implicit print

`` के बीच सब कुछ संकुचित स्ट्रिंग शाब्दिक है। वह अल्पविराम महत्वपूर्ण है। पिछली बार जब मैंने इनपुट स्टैक से पढ़ा, तो मुझे अपने आउटपुट के अंत में एक अतिरिक्त "चक" से बचने के लिए झांकने के बजाय पॉप करना चाहिए।

आप देखेंगे कि मैंने कुछ परीक्षण मामलों के लिए एक ही पंक्ति में दोनों इनपुट डाले हैं, और वे उल्टे क्रम में हैं। रिक्त स्थानों या तारों के तारों को इनपुट के रूप में लेने के लिए यह आवश्यक है।

27 26 इनपुट पर प्रतिबंध के साथ बाइट्स

å▓Zf╢7)╪♪²p╞8ó╪l▼]<¡REïSèΣ

भागो और इसे staxlang.xyz पर डीबग करें!

वैसे ही जैसे @ dzaima के SOGL , इस विफल हो जाएगा यदि पहला इनपुट छोटा अक्षर 'y' में शामिल है। स्ट्रिंग को धक्का देता है "एक बी कितना y से हो सकता है अगर एक yb?", तो प्रतिस्थापन की एक जोड़ी बनाता है।

— खुल्द्रेसथ न’बैरी
स्रोत

"आप देखेंगे कि मैंने दोनों इनपुट को कुछ परीक्षण मामलों के लिए एक ही लाइन पर रखा है, और यह कि वे रिवर्स ऑर्डर में हैं। इनपुट के रूप में रिक्त स्थान या तारों के तार लेना आवश्यक है।" यदि आप कोई इनपुट विभाजक का उपयोग नहीं करते हैं, तो इनपुट undisturbed , खाली तार और सभी होगा। यह सिर्फ कई तरह के परीक्षण मामलों को दिखाने के लिए इसे अजीब बनाता है।

— पुनरावर्ती

1

इसके अतिरिक्त, ऐसा लगता है कि ,आपके 31 बाइट समाधान में अग्रणी को हटाया जा सकता है। +इनपुट स्टैक से निम्न अंतर्निहित पॉप होता है, इसलिए व्यवहार समान है।

— पुनरावर्ती

13

जावास्क्रिप्ट, 70 बाइट्स

उबाऊ!

a=>b=>`How much ${a} would a ${a+b} ${b} if a ${a+b} could ${b} ${a}?`

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

हल्का कम उबाऊ!

a=>"How much 0 would a 01 1 if a 01 could 1 0?".replace(/\d/g,x=>a[x])

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

— झबरा
स्रोत

क्या आपको उस पहले उदाहरण की तरह एक करीने वाले फ़ंक्शन को आउटपुट करने की अनुमति है?

— Feathercrown

@Feathercrown, मैं किसी फ़ंक्शन को आउटपुट नहीं कर रहा हूं , मैं दोनों (जैसे ) कॉल कर रहा हूं f(a)(b)जैसा कि आप TIO में देख सकते हैं। लेकिन हां, हमारी सहमति से करीने वाले कार्यों की अनुमति देने के लिए और मुझे लगता है कि हम एक फ़ंक्शन को वास्तव में वापस करने की अनुमति देने पर आम सहमति के करीब हैं।

— झबरा

आउटपुट से मेरा मतलब था कि कोड मूल्यांकन किए जाने पर एक फ़ंक्शन देता है; कोई कॉलिंग दिए गए कोड में नहीं है जो बाइट्स के लिए मायने रखता है। मैं सिर्फ यह सुनिश्चित करने के लिए जाँच कर रहा था कि करीना ठीक थी, क्योंकि मैंने केवल कभी नॉनक्रीड किए गए कार्यों को देखा है।

— पंख

6

एसओजीएल , 32 30 बाइट्स

^.](9V;⅜‛°@Ε¬tπs%.½Ω‘⁽ b,ŗ y,ŗ

यहाँ यह कोशिश करो!

पहले इनपुट में वह अक्षर नहीं हो सकता है y, जो ASCII (और यूनिकोड) के एक उचित उपसमूह को छोड़ता प्रतीत होता है।

½ouiīZģ9Ο|ΧyΚ⅞ō÷Jeq(‚7‘एक संपीड़ित स्ट्रिंग है "how much b would a by y if a by could y b?"(पात्रों को चुना गया है ताकि आवश्यक शब्द सभी शब्दकोश के शीर्ष 512 शब्दों में हैं जो बेहतर सेक करते हैं), फिर b1 इनपुट के yसाथ और 2 के साथ बदल दिया जाता है ।

— dzaima
स्रोत

सबसे यादृच्छिक प्रतिबंधों में से एक के लिए +2 इंटरनेट पॉइंट्स जो मैं याद कर सकता हूं (आपके छोटे समाधान में)

— ग्रेग मार्टिन

@GregMartin यादृच्छिक नहीं है । मैं एसओजीएल नहीं बोलता, लेकिन मैंने दो प्रतिस्थापन y -> woodऔर अनुक्रमण करते समय 'एन' पर एक ही प्रतिबंध के साथ समाप्त किया n -> chuck। डिग्निटी पॉइंट के दसवें हिस्से का कहना है कि यहाँ भी ऐसा ही है।

— खुल्द्रेशेथ न'बर्या

मुझे लगता है कि इस प्रश्न की मुख्य भावना समाधानों की अनुमति देने के बारे में खुला होना है ... केवल एक तरफ के रूप में मैं यह स्पष्ट कर सकता हूं कि इनपुट में एक वास्तविक पत्र की अनुमति नहीं देना थोड़ा स्केच है। वैसे भी: bपहले इनपुट में अनुमति क्यों नहीं दी गई है फिर भी eदूसरे इनपुट में ठीक है?

— ग्रेग मार्टिन

@GregMartin जो कहता है, मेरा कहने का मतलब था कि 1 इनपुट में नहीं हो सकता है e, अन्यथा यह 2 रीप्लेसमेंट में 2 इनपुट के साथ प्रतिस्थापित किया जाएगा

— dzima

क्या इनपुट से अल्फा पर प्रतिबंध लगाने से बचने के लिए गैर-अल्फ़ा होना प्रतिस्थापन लक्ष्य के लिए संभव नहीं है?

— WGroleau

5

आर , 90 77 76 बाइट्स

-13 सुमेर 18
के लिए धन्यवाद -1 ग्यूसेप के लिए

function(x,y,`[`=gsub)2[y,1[x,"How much 1 would a 12 2 if a 12 could 2 1?"]]

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

— रॉबर्ट एस।
स्रोत

2

gsubइसके बजाय -13 बाइट्स के लिए डबल कर सकते हैं । tio.run/…

— Sumner18

@ Sumner18 धन्यवाद। हाँ, gsubनिश्चित रूप से अधिक समझ में आता है।

— राबर्ट एस।

यदि आप का उपयोग करने का मन करता है pryr, तो आप इसे 73 तक नीचे ला सकते हैं ।

— खुल्द्रेसैथ न'बर्या

4

आपको यह निर्दिष्ट करना चाहिए कि आप मानते हैं कि इनपुट xमें चरित्र शामिल नहीं है 2; यह इस मामले (में विफल रहता है TIO )।

— रॉबिन राइडर

4

76 के साथ gsub का उपनाम

— Giuseppe

4

PHP , 72 बाइट्स

[,$a,$b]=$argv;echo"How much $a would a $a$b $b if a $a$b could $b $a?";

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

या:

PHP , 72 बाइट्स

How much <?=![,$a,$b]=$argv,"$a would a $a$b $b if a $a$b could $b $a?";

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

कमांड लाइन से इनपुट, आउटपुट से STDOUT।

— 640KB
स्रोत

4

जावास्क्रिप्ट (V8) , 72 बाइट्स

(a,b)=>['How much',a,'would a',c=a+b,b,'if a',c,'could',b,a+'?'].join` `

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

चर असाइनमेंट वास्तव में 0 बाइट्स बचाता है, लेकिन मुझे लगा कि मैं इसे थोड़े अनोखे बनाने के लिए रखूंगा।

— IronFlare
स्रोत

लेकिन एक बड़ा टेम्पलेट स्ट्रिंग 1 वर्ण छोटा है: इसे ऑनलाइन आज़माएं! ।

— मैनटवर्क

@ मैनटवर्क मैंने यह कोशिश की, लेकिन गलती से एक अतिरिक्त स्थान शामिल हो गया: पी धन्यवाद!

— आयरनफ्लारे

4

जेडएक्स स्पेक्ट्रम बेसिक, 87 बाइट्स

बस पूर्णता के लिए, सीधा कार्यान्वयन:

INPUT a$,b$: PRINT "How much ";a$;" would a ";a$;b$;"  ";b$;" if a ";a$;b$;" could ";b$;" ";a$;"?"

IFकीवर्ड (1 बाइट) का उपयोग करके इसे 3 बाइट्स से नीचे गिराया जाता है, लेकिन "समान कैपिटलाइज़ेशन" स्थिति को तोड़ता है:

INPUT a$,b$: PRINT "How much ";a$;" would a ";a$;b$;"  ";b$;" IF a ";a$;b$;" could ";b$;" ";a$;"?"

— रादोवन गरबीक
स्रोत

यह थोड़ा-धोखा संस्करण भी दिखाने के लिए अच्छा है :)

— ग्रेग मार्टिन

2

ओह, विशिष्टता! फिर से जवान होने के लिए ...

— chx

4

जंग , 75 बाइट्स

|a,b|print!("How much {} would a {0}{} {1} if a {0}{1} could {1} {0}?",a,b)

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

इस ट्रिक का उपयोग करते हुए , जो आप फॉर्मेट इंडेक्स को एक बार प्रति आइटम फॉर्मेट में छोड़ देते हैं।

यह भी उपयोग कर रहा है print!(), क्योंकि यह एक बाइट के साथ एक स्ट्रिंग बनाने format!()और इसे वापस करने से कम है।

— ruohola
स्रोत

4

05AB1E , 37 35 31 30 बाइट्स

“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“T$ú‡

-5 बाइट्स @Grimy के लिए धन्यवाद ।

दो वस्तुओं की सूची लेता है: woodपहला मान और chuckदूसरा।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“
      # Push dictionary string "How much1 would a ÿ0 if a ÿ could01?",
      # where the `ÿ` are automatically filled with the (implicit) input-list,
      # implicitly joined together to a single string
      #  i.e. ["wood","chuck"] → "How much1 would a woodchuck0 if a woodchuck could01?"
T     # Push 10
 $    # Push the input-list and 1
  ù   # Pad the strings in the input-list with this 1 amount of leading spaces
      #  ["wood","chuck"] → [" wood"," chuck"]
   ‡  # Transliterate the 10 ([1,0]) to these strings in the sentence
      #  → "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
      # (after which the result is output implicitly)

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों “Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“है "How much1 would a ÿ0 if a ÿ could01?"।

— केविन क्रूज़सेन
स्रोत

1

31

— ग्रिम्मी

1

30

— ग्रिम्मी

1

@Grimy बहुत अच्छा! मैं वास्तव में उन दोनों को पसंद करता हूं। $ùअतिरिक्त बाइट को बचाने के लिए उस तरह का उपयोग करने का सरल विचार , धन्यवाद।

— केविन क्रूज़सेन

1

वैकल्पिक 30 । मुझे कोई 29 नहीं मिल रहा है, इसलिए आपका स्पष्टीकरण अभी के लिए सुरक्षित है;)

— ग्रैमी

4

अप्लेसॉफ्ट बेसिक, 77 76 बाइट्स

1INPUTA$,B$:?"How much "A$" would a "A$B$" "B$" if a "A$B$" could "B$" "A$"?

उपरोक्त उचित BASIC की तरह नहीं लग सकता है, लेकिन स्टेटसॉफ्ट PRINTस्टेटमेंट का उपयोग करते समय कुछ शॉर्टकट की अनुमति देता है :

का प्रयोग करें ?के स्थान पर PRINTजब बयान में प्रवेश
संयोजन वर्ण (या तो ;या +) हटाया जा सकता है
यदि कथन एक उद्धृत स्ट्रिंग में समाप्त होता है, तो अंतिम उद्धरण को छोड़ दिया जा सकता है धन्यवाद, निशान !

लाइन नंबर की आवश्यकता है, या INPUTबयान एक कारण होगा?ILLEGAL DIRECT ERROR

— ली
स्रोत

1

क्या आप अनुगामी उद्धरण चिह्न को छोड़ सकते हैं? अप्लेसॉफ्ट बेसिक एक Microsoft बेसिक व्युत्पन्न है, और Microsoft बेसिक के कई संस्करण आपको एक स्ट्रिंग पर समापन उद्धरण को छोड़ देते हैं यदि यह लाइन को समाप्त करता है।

— मार्क

@ मार्क, टिप के लिए धन्यवाद!

— lee

4

33 , 78 बाइट्स

"How much "p1btpt" would a "ptpz2btp" "ptbtp" if a "ptpbtp" could "ptbtp" "ptp

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

इनपुट को कमांड-लाइन तर्क के रूप में लेता है।

बोनस: 91 बाइट्स

"How much "p1bztp" would a "p1bztp2bztp" "p2bztp" if a "p1bztp2bztp" could "p2bztp" "p1bztp

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

खुद से मिलता-जुलता उत्पादन देता है जब आदानों दिया 1bztpऔर2bztp

— TheOnlyMrCat
स्रोत

यह ज़ोर से कहा, अब मुझे अपने मॉनिटर से सभी थूक को साफ करने की आवश्यकता है।

— ब्रैडेक

3

कोटलिन , 59 बाइट्स

{i,j->"How much $i would a $i$j $j if a $i$j could $j $i?"}

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

— क्विन
स्रोत

बहुत मज़ा आता है कोटलिन!

— M.Herzkamp

1

@ M.Herzkamp यह निश्चित है!

— क्विन

3

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

param($a,$b)"How much $a would a $a$b $b if a $a$b could $b $a`?"

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

ध्यान देने वाली बात केवल यह है कि आपको प्रश्न चिह्न से बचना होगा क्योंकि वे पॉवरशेल पहचानकर्ता के मान्य भाग हो सकते हैं

— Veskah
स्रोत

3

VBA, 107 बाइट्स

Function q(a,b)
b=b&" "
c="ould "
q="How much "&a&" w"&c&"a "&a&b&b&"if a "&a&b&"c"&c&b&a&"?"
End Function

VBScript के रूप में भी चलना चाहिए, मैंने दो शॉर्टकट का उपयोग किया: "ould" दोहरा रहा है और "चक" कभी भी एक अतिरिक्त स्थान के बिना प्रकट नहीं होता है।

— user3819867
स्रोत

आप इसे तत्काल विंडो फ़ंक्शन में परिवर्तित करके 75 बाइट्स तक प्राप्त कर सकते हैं a=[A1]:b=[B1&" "]:o="ould ":?"How much "a" w"o"a "a b b"if a "a b"c"o b a"?। [A1]और से इनपुट लेता है [B1]। हमारे पास VBA में गोल्‍फिंग के लिए टिप्‍स हैं जिन पर आप गौर करना चाहते हैं।

— टेलर स्कॉट

तो फिर तुम इनपुट नामांकित श्रेणी ले सकता है [A]और [B]के रूप में आदानों 73. करने के लिए नीचे यह लाने मैं काफी समझ में नहीं आता कि कैसे तुम्हारा के माध्यम से हालांकि चला जाता है, अपने खुद के जवाब में जोड़ने के लिए स्वतंत्र लग रहा है।

— user3819867

1

दुर्भाग्य से एसटीडीआईएन और एसटीडीयूएस को एक्सेल वीबीए के लिए कैसे परिभाषित किया गया है, इसके खिलाफ जाता है - आप एक्टीवेट पर किसी भी अनाम रेंज का उपयोग कर सकते हैं, लेकिन समुदाय द्वारा पहले के डिकसन के अनुसार नामित रेंज का उपयोग करने की अनुमति नहीं है

— टेलर स्कॉट

3

सी # , 165 148 133 बाइट्स

class P{static void Main(string[]a){System.Console.Write("How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?\n",a[0],a[1]);}}

अन्तर्निहित तार के बारे में बताने के लिए एंड्रयू बॉमर को धन्यवाद !!
संपादित करें: पूर्ण वर्ग ने अब
EDIT को जोड़ा : केनेथ के। के लिए धन्यवाद , मुझे इसे छोटा करने के लिए कुछ सुझाव दिए।
EDIT: एंड्रयू को धन्यवाद फिर से मुझे यह बताने के लिए कि प्रक्षेपित स्ट्रिंग का उपयोग करना वास्तव में इस परिदृश्य में लंबा है।

— canttalkjustcode
स्रोत

आधुनिक C # 's' $ '( प्रक्षेपित स्ट्रिंग्स ) का उपयोग करके , आप {0} को {[a]] के साथ बदलकर या फिर अभी तक दो वेरिएबलों को एक सरणी के बजाय ले कर कुछ बाइट्स बचा सकते हैं ताकि आप बस a और b का उपयोग कर सकें। तो अपनी गड़गड़ाहट चोरी नहीं करने के लिए, इसलिए बोलने के लिए, मैं इसे c # के एक अलग संस्करण के रूप में

— जोड़ूंगा

वाह उस बारे में पता नहीं था! जानकारी के लिए धन्यवाद

— Canttalkjustcode

2

@canttalkjustcode आम तौर पर, कार्य स्वीकार किए जाते हैं। C # के लिए, इसमें लैम्ब्डा शामिल है:a=>System.Console.WriteLine($"How much {a[0]} would a {a[0]}{a[1]} {a[1]} if a {a[0]}{a[1]} could {a[1]} {a[0]}?")

— JAD

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

— कैंटोकॉलीकोडकोड

void M(string[]a){System.Console.WriteLine($"How much {a[0]} would a {a[0]}{a[1]} {a[1]} if a {a[0]}{a[1]} could {a[1]} {a[0]}?");}

System.Func<string>M=a=>System.Console.WriteLine($"How much {a[0]} would a {a[0]}{a[1]} {a[1]} if a {a[0]}{a[1]} could {a[1]} {a[0]}?");

System.Action<string>M=a=>System.Console.WriteLine($"How much {a[0]} would a {a[0]}{a[1]} {a[1]} if a {a[0]}{a[1]} could {a[1]} {a[0]}?");

— २०:३४ पर छावनी

3

हास्केल , 76 बाइट्स

a?b=a++" "++b
a!b="How much"?a?"would a"?a++b?b?"if a"?a++b?"could"?b?a++"?"

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

पहले प्रयास करें, इसलिए मुझे आशा है कि मैंने कोई नियम नहीं तोड़ा।

— डेविड
स्रोत

2

जेली , 39 बाइट्स

ŒPKŒP“µkþ¿µ‘ị“þ>Æƈ)taJṖ;ạʂ\4S%dñl»Ỵ¤ż”?

एक पूरा कार्यक्रम दो तार की सूची को स्वीकार करता है।

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

... या (दो तारों की एक सूची को स्वीकार करने वाला एक पूर्ण कार्यक्रम)

⁽4ṀDBịs€2ṭ€€⁶“þ>Æƈ)taJṖ;ạʂ\4S%dñl»Ỵ¤ż”?

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

— जोनाथन एलन
स्रोत

2

पायथन 3 , 80 बाइट्स

lambda n:'How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?'.format(*n)

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

जब रोम में, str प्रारूप का उपयोग करें।

स्क्वीड की चाल का उपयोग कर संपादित किया गया ।

— Tryer
स्रोत

3

क्या यह अमान्य नहीं होगा? यह एक स्निपेट है - फ़ंक्शन या प्रोग्राम नहीं, सही?

— मोनिका

हाँ; lambda n:इससे पहले की जरूरत है , और छोड़ सकते हैं print()।

— wizzwizz4

How much ...इसके बजाय प्रिंट करने के लिए आपको अपना कोड बदलना चाहिए how much ...।

— रूहोला

3

यह केवल एक अनाम फ़ंक्शन को परिभाषित करने के लिए पर्याप्त होना चाहिए 'how much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?'.format।

— xnor

@ xnor अभी भी बहुत नया है, TIO उस समय के लिए कैसा दिखेगा? मुझे लगता है कि किसी तरह से एक arg में पारित करने के बिना यह runnable होगा।

— कोशिशकर्ता

2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 66 65 बाइट्स

x=>y=>$"How much {x} would a {x+y} {y} if a {x+y} could {y} {x}?"

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

C # को छोड़कर बाकी सभी को समान। -1 बाइट का उपयोग करके स्ट्रेटिंग स्ट्रैट ए => बी => सी के बजाय (ए, बी) => सी

— एंड्रयू बाउमर
स्रोत

से समारोह हस्ताक्षर बदलें Func<string,string,string>करने के लिए Func<string,Func<string,string>>और परिवर्तन (x,y)करने के लिएx=>y=>

— अज्ञान की अवतार

एक सस्ती रणनीति की तरह लगता है, लेकिन मेटा चर्चा का कहना है कि यह उचित खेल है, इसलिए भी हो सकता है। धन्यवाद।

— एंड्रयू बॉमर

2

आर , 95 बाइट्स

function(a,b)cat("How much ",a," would a ",a,b," ",b," if a ",a,b," could ",b," ",a,"?",sep='')

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

— minhsphuc12
स्रोत

2

साइट पर आपका स्वागत है! आपका TIO लिंक गलत कोड से लिंक लगता है? इसके अलावा, जहाँ तक मैं बता सकता हूँ, आपने इनपुट को चर में होने के लिए मान लिया है aऔर bजो हमारे डिफ़ॉल्ट इनपुट / आउटपुट नियमों के

— caird coinheringaahing

टिप्पणी के लिए धन्यवाद @cairdcoinheringaahing। मैंने इसे फ़ंक्शन रूप में फिर से लिखा है, आशा है कि यह अब नियमों का अनुपालन करता है।

— minhsphuc12

उपयोग करने stringrसे आपकी कुछ बचत होती है।

— खुल्द्रेसथ ना'बरिया

1

एपीएल (डायलॉग यूनिकोड) , 56 59 बाइट्स

{∊'How much '⍺' would a '⍺⍵' '⍵' if a '⍺⍵' could '⍵' '⍺'?'}

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

बहुत सीधा dfn। ∊यदि हम एक स्ट्रिंग के बजाय स्ट्रिंग्स की एक सरणी वापस करने की अनुमति देते हैं, तो एक बाइट काटकर बचाता है ।

3 बाइट्स जोड़े गए क्योंकि मैं प्रश्न चिह्न जोड़ना भूल गया था।

— जे। सल्ल
स्रोत

क्या आपने ग्रीक अक्षरों को एक बाइट के रूप में गिना है?

— टॉम ज़ातो

@ TomášZato हाँ। Dyalog APL के ग्लिफ़ को Adám के सिंगल बाइट कैरेक्टर शीट का उपयोग करके एकल बाइट में दर्शाया जा सकता है, जो यहाँ APL उत्तरों के लिए मानक है।

— जे। सले

1

वोल्फ्राम भाषा (गणितज्ञ) , 68 बाइट्स

StringRiffle@{How,much,#,would,a,c=#<>#2,#2,if,a,c,could,#2,#<>"?"}&

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

— attinat
स्रोत

1

जेली , 41 37 बाइट्स

⁾be,y“Ø[gœıJ9°m.OṚuHlh3Ƥ⁾$ɲ0øḲʂṇHẎṆȥ»

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

एक पूर्ण कार्यक्रम अपने तर्क के रूप में तार की एक जोड़ी ले रहा है और संसाधित स्ट्रिंग को प्रिंट कर रहा है। Fअंत में जोड़कर एक मोनडिक लिंक बनाया जा सकता है (यह इंगित करने के लिए @JonathanAllan के लिए धन्यवाद)।

अब मैं "b" और "e" को प्लेसहोल्डर्स के रूप में उपयोग करने के लिए स्विच कर रहा हूं, जो @ dimaima के SOGL उत्तर से प्रेरित है, इसलिए सुनिश्चित करें कि वह भी अपवोट हो! इसका मतलब यह है कि पहला शब्द अक्षर ई को शामिल नहीं कर सकता है।

— निक केनेडी
स्रोत

@JonathanAllan काफी सही! धन्यवाद।

— निक केनेडी

1

जाप `-S` , 44 39 बाइट्स

[`How Û2`U`Ùd a`N=¬V`if a`N`Öd`VU+'?]

कोशिश करो

— झबरा
स्रोत

1

फोर्थ (gforth) , 116 बाइट्स

: x 2over type ; : y 2dup type ; : f ." How much "x ."  would a "x y ."  "y ."  if a "x y ."  could "y ."  "x ." ?";

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

कोड स्पष्टीकरण

\ x = output the first word
: x               \ start a new word definition
  2over type      \ copy the "first" word to the top of the stack and print it
;                 \ end word definition

\ y = output the second word
: y               \ start a new word definition
  2dup type       \ copy the "second" word to the top of the stack and print it
;                 \ end word definition

: f               \ start a new word definition
  ." How much "x  \ print "How much " followed by the first word   
  ."  would a "x  \ print " would a " followed by the first word
  y ."  if a "x   \ print the second word followed by " if a " and then the first word
  y ."  could "y  \ print the second word, then " could " then the second word again
  ."  "x ." ?"    \ print a space followed by the first word, followed by "?"
;                 \ end word definition

— reffu
स्रोत

1

लूआ , 82 बाइट्स

a,b=...print((('How much x would a xy y if a xy could y x?'):gsub('.',{x=a,y=b})))

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

पूर्ण कार्यक्रम, तर्कों के रूप में इनपुट लें।

यहां कुछ खास नहीं। आशा है कि इसका छोटा संस्करण है, लेकिन पहली नज़र में इसे छोटा करने का कोई स्पष्ट तरीका नहीं है।

— वैल
स्रोत

1

बैश , 58 बाइट्स

echo "How much $1 could a $1$2 $2 if a $1$2 could $2 $1?"

कमांड लाइन तर्क के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

— gadzooks02
स्रोत

एक कोडगॉल्फ गोल्फ कितना कोड अगर एक कोडगॉल्फ गोल्फ कोड सकता है?

पायथन 3 , 70 67 बाइट्स

टी-एसक्यूएल, 82 बाइट्स

बैश , 50 बाइट्स

स्टैक्स , 33 31 30 29 बाइट्स

अनपैक्ड (35 बाइट्स) और स्पष्टीकरण:

27 26 इनपुट पर प्रतिबंध के साथ बाइट्स

जावास्क्रिप्ट, 70 बाइट्स

एसओजीएल , 32 30 बाइट्स

आर , 90 77 76 बाइट्स

PHP , 72 बाइट्स

PHP , 72 बाइट्स

जावास्क्रिप्ट (V8) , 72 बाइट्स

जेडएक्स स्पेक्ट्रम बेसिक, 87 बाइट्स

जंग , 75 बाइट्स

05AB1E , 37 35 31 30 बाइट्स

अप्लेसॉफ्ट बेसिक, 77 76 बाइट्स

33 , 78 बाइट्स

बोनस: 91 बाइट्स

कोटलिन , 59 बाइट्स

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

VBA, 107 बाइट्स

सी # , 165 148 133 बाइट्स

हास्केल , 76 बाइट्स

जेली , 39 बाइट्स

पायथन 3 , 80 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 66 65 बाइट्स

आर , 95 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 56 59 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 68 बाइट्स

जेली , 41 37 बाइट्स

जाप -S , 44 39 बाइट्स

फोर्थ (gforth) , 116 बाइट्स

कोड स्पष्टीकरण

लूआ , 82 बाइट्स

बैश , 58 बाइट्स

जाप `-S` , 44 39 बाइट्स