बतख बतख हंस!

58

बच्चों का खेल, 'डक, डक, गूज' याद है ? नहीं? न ही मैं।

चुनौती

  • 'डक' शब्द को अलग-अलग पंक्तियों पर अनिश्चित समय के लिए प्रिंट करें।
  • 'हंस' शब्द को छापें।
  • आपका कार्यक्रम समाप्त होता है।

नियम

  • सबसे कम बाइट्स में गेम खेलने का प्रयास करें।
  • कम से कम एक बत्तख होनी चाहिए।
  • सूची के अंत में एक हंस होना चाहिए।
  • प्रत्येक पंक्ति में ठीक एक पक्षी होना चाहिए। कोई खाली लाइनें नहीं।
  • आउटपुट स्ट्रिंग्स का मामला अप्रासंगिक है।
  • एक पंक्ति के भीतर सफेद-स्थान ठीक है।
  • आपका कार्यक्रम समाप्त होना चाहिए।
  • आपके प्रोग्राम को लगातार एक ही संख्या में बतखों का उत्पादन नहीं करना चाहिए।

मज़े करो!

कृपया ध्यान दें: यह प्रश्न गैर-निर्धारक उत्पादन का उत्पादन करने के लिए सबसे छोटा कोड का डुप्लिकेट नहीं है

कारणों में शामिल हैं:

  • बच्चों के खेल से जुड़ाव
  • परिणाम स्ट्रिंग की परिभाषित शुरुआत और अंत आवश्यकताएं। अन्य चुनौती में कोई निर्दिष्ट आउटपुट नहीं है।
  • अन्य, गैर-डुप्लिकेट चुनौती बाइट्स की एकल-अंक संख्या में हैं। इस एक के लिए औसत लगभग 30 है, या इसके बारे में है।
  • इस चुनौती और उस एक के बीच ओवरलैप की राशि से, 'यादृच्छिक' टैग सहित किसी भी कोड-गोल्फ प्रश्न एक डुप्लिकेट है। क्या हमें उन सभी को हटाना चाहिए?
  • इस चुनौती के लिए कोड के जवाब दूसरी चुनौती से मेल खाते होंगे (हास्यास्पद तरीके से)। लेकिन उस चुनौती के जवाब किसी से मेल नहीं खाते।
code-golf  random 
— AJFaraday
स्रोत
11
क्या आप अनिश्चितता को परिभाषित कर सकते हैं? क्या इसका मतलब शून्य या एक हो सकता है?
— पुनरावर्ती
1
कृपया यह परिभाषित करें कि यह कैसे यादृच्छिक रूप से उत्पन्न किया जाना चाहिए। सीमा में समान या घातीय गिरावट के साथ?
— हाइपरएन्यूट्रीनो
@recursive नहींं, लेकिन चलो एक कार्यशील परिभाषा के साथ चलते हैं ... कार्यक्रम लगातार बत्तख की संख्या को प्रस्तुत नहीं करता है।
— AJFaraday
2
मिनेसोटन के रूप में बोलते हुए, क्या होगा अगर मेरा बजाय "बतख, बतख, ग्रे बतख" प्रिंट करता है ? :)
— माइक हिल
1
@ jpmc26 मुझे यकीन है कि अन्य लोग भी हैं। शुरुआत के लिए आपको इसे दूसरों के साथ खेलना होगा।
— AJFaraday

जवाबों:

9

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

2X“¢;ÆS»ẋ“ʋ¢»

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

स्पष्टीकरण:

2X“¢;ÆS»ẋ“ʋ¢»

2X             Random number (1 or 2)
  “¢;ÆS»       Compressed string equivalent to "duck\n"
        ẋ      Repeat the "duck\n" that random number of times
         “ʋ¢»  Compresses string equivalent to "goose"
               Implicitly concatenated and returned

अधिक पठनीय संस्करण: इसे ऑनलाइन आज़माएं!

हमेशा 1 या 2 बत्तख लौटाएंगे।

— user202729
स्रोत
बधाई! मुझे सचमुच पता नहीं है कि यह कैसे काम करता है!
— AJFaraday
@AJFaraday मैं आगे गया और आपके लिए एक स्पष्टीकरण जोड़ा
— PunPun1000
@ PunPun1000 क्षमा करें, लेकिन स्टैक क्या है? जेली एक टैसिट प्रोग्रामिंग भाषा है।
— user202729
@ user202729 ओह, मुझे जेली मिली और 05AB1E मेरे सिर में गड़बड़ी हो गई, क्या आप इस त्रुटि को ठीक करने के लिए इसे संपादित कर सकते हैं? इसके बारे में क्षमा करें
— PunPun1000
जेली में निहित प्रभाव है? वाह!
— MilkyWay90
43

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 48 बाइट्स

f={s="duck\n";s+([s,""]select random 1)+"goose"}

हमेशा एक या दो बतख प्रिंट करता है।

random 10 और 1. के बीच एक फ़्लोटिंग (फ़्लोटिंग पॉइंट) नंबर देता है। उस नंबर को selectऐरे के साथ एक तर्क के रूप में पास किया जाता है [s,""]। फिर यादृच्छिक संख्या को निकटतम पूर्णांक (या तो 0 या 1) पर गोल किया जाता है, और उस सूचकांक में सरणी तत्व को सरणी से चुना जाता है।

के साथ बुलाना:

hint call f

आउटपुट:

वैकल्पिक 56 बाइट्स संस्करण:

f={s="duck\n";format[s+"%1goose",[s,""]select random 1]}
— Steadybox
स्रोत
3
यह हमेशा मुझे खुश करता है जब कोई पीसीजी पर इसका उपयोग करता है।
— नित
वैसे मैं इस खेल को भूल गया।
— कैमेन
38

Warcraft की दुनिया 81 बाइट्स

यहां एक मैक्रो है जिसे आप वर्ल्ड ऑफ वॉरक्राफ्ट में चला सकते हैं।

/run for x=1,random(1,9) do SendChatMessage("Duck") end; SendChatMessage("Goose")
— केली लोडर
स्रोत
11
ओह माई लॉर्ड ... मैंने ऐसा कभी क्यों नहीं सोचा।
— मैजिक ऑक्टोपस Urn
4
PVCG (प्रोग्रामिंग वीडियोगेम और कोड गोल्फ)। ऑपरेशन फ्लैशप्वाइंट एक चीज थी, लेकिन वाह? मैं इस के Minecraft और Factorio समाधान की प्रतीक्षा कर रहा हूं।
— ब्रेन गाइडर
2
@AnderBiguri मुझे संदेह है कि Minecraft एक 81 बाइट्स (ब्लॉक?)?) से थोड़ा खराब काम करेगा
— क्रिस
5
यह काम करना चाहिए और आपको 58 बाइट्स तक ले जाना चाहिए:/run for x=1,random(1,9)do print("Duck")end print("Goose")
— गैस्ट्रोपनर
35

Minecraft <1.13, 72 54 बाइट्स

क्षमा करें, मुझे करना पड़ा।

निर्देश:

  • क्रिएटिव मोड में एक नया Minecraft दुनिया बनाएं
  • उस दुनिया के लिए सहेजें फ़ोल्डर ढूंढें, और निम्न कोड को अंदर रखें data/functions/minecraft/ddg.mcfunction
  • /function ddgगेम कंसोल में चलाएं

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

दुनिया में हर इकाई के लिए "बतख" शब्द का उत्पादन करता है, फिर "हंस" शब्द का उत्पादन करता है। चूंकि इकाइयां लगातार स्पॉइंग और डीसपॉइंग कर रही हैं, इसलिए "बतख" की संख्या सुसंगत नहीं होगी। मैंने tellrawबहुत कम के बजाय उपयोग किया sayक्योंकि sayइकाई का नाम आउटपुट करता है, जबकि tellrawआउटपुट वास्तव में यह बताया गया है।

execute @e ~ ~ ~ tellraw @a "duck"
tellraw @a "goose"

स्क्रीनशॉट

यहाँ छवि विवरण दर्ज करें

संपादित करें: बदला हुआ {"पाठ": "बतख"} को सिर्फ "बतख" (और "हंस" के साथ भी)

— FlyingPiMonster
स्रोत
1
सुंदर। हमें PPCG में अधिक Minecraft की आवश्यकता है।
— ब्रैडेक
9
यह उल्लेख करते हुए कि आप (खिलाड़ी) दुनिया में एक इकाई हैं, इसलिए बतख की संख्या कभी भी 0 नहीं हो सकती है (भले ही कोई शत्रुतापूर्ण या निष्क्रिय भीड़ न हो)।
— ब्रैडेक
1
@ ब्रैडक में Minecraft के आसपास पूरी चुनौतियां होनी चाहिए।
— विषहरी
17

जावास्क्रिप्ट, 45 44 42 39 37 बाइट्स

एक अतिप्रवाह त्रुटि का उत्पादन करने की क्षमता है।

f=_=>`duck
${new Date%2?f():`goose`}`

झसे आज़माओ

o.innerText=(
f=_=>`duck
${new Date%2?f():`goose`}`
)()
<pre id=o></pre>
स्निपेट का विस्तार करें

— झबरा
स्रोत
14

ऑक्टेव , 38 33 बाइट्स

यह सबसे छोटा नहीं है (यह 36 बाइट्स है), लेकिन यह मेरा पसंदीदा है। स्पष्टीकरण नीचे में है।

disp(['duck '+~(1:1/rand)';'goose'])

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

कुछ छोटे बदलाव:

यह सिद्धांत (33 बाइट्स) में काम करता है, लेकिन ऑनलाइन दुभाषियों के समय से बाहर:

disp(['duck '+~(1:now)';'goose'])

आउटपुट को छोटा बनाने के लिए कुछ बाइट्स जोड़ना 35 या 36 बाइट्स बनाता है:

disp(['duck '+~(7e5:now)';'goose'])   % Works on octave-online.net
disp(['duck '+~(7.3e5:now)';'goose']) % Works on tio.run

स्पष्टीकरण:

मैं सिर्फ अंतिम यादृच्छिक समझाता हूँ। अन्य समान हैं, लेकिन 1 जनवरी, 0000 से लेकर आज तक के दिनों की संख्या का उपयोग करता है।

randअंतराल (0, 1) पर एक यादृच्छिक संख्या देता है । इस प्रकार, 11/rand से बड़ी संख्या देता है । एक सीमा के बाद , जहां 1 से बड़ा यादृच्छिक फ्लोट होता है , एक समान होता है , एक सीमा बनाता है 1 .. x , जहां x> = 1 ।1:ff1:floor(f)1:1/rand

मैं इसे समझाने की कोशिश करूँगा जैसे कि ऑक्टेव एक स्टैक आधारित भाषा थी। 

      'duck '                           % Push the string 'duck ' to the stack
               (1:1/rand)               % Push a vector 1... floor(1/rand)
              ~(1:1/rand)'              % Negate the vector (making it all zeros)
                                        % and transpose it.
             +                          % Add 'duck ' with the vertical vector of zeros
                                        % to implicitly duplicate the string r times
     [                    ;'goose']     % Push the string 'goose' and concatenate
                                        % vertically with the rest
disp(                              )    % Display it all.
— स्टीवी ग्रिफिन
स्रोत
disp(['duck '+~pwd';'goose'])? यकीन नहीं होता कि यह "अनिश्चित" पर्याप्त है
— लुइस मेंडो
12

पर्ल 5 , 20 बाइट्स

पहले एक व्यावहारिक 26 बाइट्स:

जाने से पहले 1 से 9 बार बतख।

say"Duck
"x(1+$^T%9),Goose

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

लेकिन अगर आपके पास बहुत सारी मेमोरी और समय है यह 20 बाइट संस्करण (जैसा कि क्रिस द्वारा सुझाया गया है ) भी काम करता है:

say"Duck
"x$^T,Goose

यह भी मानता है कि वर्ष 2038 समस्या पर्ल 5 के लिए हल हो जाएगी , अन्यथा यह 1 सेकंड 20 वर्षों के लिए अमान्य होगा।

— टन हास्पेल
स्रोत
यदि आप 1+$^T%9बस में बदल जाते हैं $^T, तो यह अभी भी काम करता है, और आप 4 बाइट बचाते हैं।
— क्रिस
@chris तुम स्पष्ट रूप से अधिक स्मृति की तुलना में मैं करते हैं। फिर भी, मैं आपके सुझाव पर विचार करूंगा क्योंकि उचित कंप्यूटर हैं जिन पर यह काम करेगा। धन्यवाद।
— टन हास्पेल
12

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

print"duck\n"*((id(id)%5)+1),"goose"

यह ऑनलाइन की कोशिश करो!

केविन क्रूज़सेन द्वारा सुझाव हमें 34 बाइट्स के लिए मिलता है:

print"duck\n"*-~(id(id)%5),"goose"
— ग्रेग फुलर
स्रोत
3
साइट पर आपका स्वागत है, और अच्छा पहला जवाब!
— 20
PPCG में आपका स्वागत है! आप गोल्फ बदलकर दो बाइट्स कर सकते हैं ((id(id)%5)+1)करने के लिए -~(id(id)%5)कोष्ठक से छुटकारा पाने के। <सभी भाषाओं में गोल्फिंग के लिए टिप्स > और पायथन में गोल्फ के लिए युक्तियाँ पढ़ने के लिए दिलचस्प हो सकता है। यहां रहने का आनंद!
— केविन क्रूज़सेन
1
id(id)हो सकता है id(0)या मैं कुछ याद नहीं कर रहा हूँ?
— जोनाथन फ्रीच
@ जोनाथन, id(0)एक जोड़े को अलग-अलग कंप्यूटरों पर देखते हुए यह एक निरंतरता है।
— user2699
1
थोड़ा और अधिक सहज और अधिक बाइट्स कॉल करने के लिए नहीं होगा id([])। यह हर बार जब प्रोग्राम चलता है, तो एक अलग सूची को इनिशियलाइज़ करना चाहिए, जिसके सिद्धांत में लगातार अलग-अलग मेमोरी एड्रेस होने चाहिए।
— jpmc26
11

Z शैल (+ wget और Netpbm), 168 160 150 148 145 135 120 बाइट्स

d(){wget -O- bit.ly/$1|jpegtopnm|pamscale -w 64 -h 64};d DckDkGo|pnmtile 64 $[(RANDOM&7+1)*64]|pnmcat -tb - <(d g005eGG)

सबसे छोटा समाधान नहीं है, लेकिन मुझे ऐसा लगा कि इस चुनौती को एक प्रकार का मोड़ देना है ( इस अन्य समस्या के लिए @ एलेक्सजी के समाधान से प्रेरित )।

यह स्क्रिप्ट पीपीएम छवि उत्पन्न करती है जिसमें बत्तखों की 1-8 तस्वीरें और मानक आउटपुट पर सबसे नीचे एक हंस की तस्वीर होती है। यह विकिपीडिया से दो स्रोत चित्रों को डाउनलोड करता है, इसलिए काम करने के लिए इंटरनेट का उपयोग आवश्यक है।

नमूना उत्पादन pnmtojpeg के माध्यम से JPEG में परिवर्तित :

यहाँ छवि विवरण दर्ज करें

— lucasb
स्रोत
1
यह पूरी तरह से मेरा दिन बना दिया है!
— AJFaraday
मैंने महसूस किया है कि आप वही व्यक्ति हैं जिसने प्रस्तावित किया है कि मैं अन्य चुनौती से जुड़ा हूं। xD खैर, मुझे खुशी है कि आपको यह पसंद आया! = डी
— लुकासब
हां, मेरे कोड गोल्फ चुनौतियों में कुछ विषय हैं :) मुझे चित्र के जवाब के लिए बोनस अंक निश्चित रूप से देना चाहिए।
— AJFaraday
क्या यह बाहरी संसाधनों को प्राप्त करने के लिए एक मानक खामी नहीं है?
— मिल्कीवेय 90
10

आर , 35 बाइट्स

cat(rep("duck
",rexp(1)+1),"goose")

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

rexp()एक घातीय क्षय समारोह से एक यादृच्छिक संख्या पैदा करता है। +1कम से कम एक बतख सुनिश्चित करने के लिए। पहली के बाद की सभी पंक्तियों में एक प्रमुख स्थान (जो डिफ़ॉल्ट विभाजक है cat) शामिल है, लेकिन इसकी अनुमति है।

— user2390246
स्रोत
1
एक से अधिक बत्तखों के उत्पादन की संभावना exp(-1)36.8% या उसके आसपास है।
— Giuseppe
यह प्रत्येक लाइन पर इसे प्रिंट करने के लिए कहता है। मुझे लगता है कि आपको अपने "बत्तख" में "\ n" जोड़ना चाहिए
— स्टुअर्ट स्टीवेंसन
3
@stuartstevenson यहाँ मैंने एक शाब्दिक नई पंक्ति का प्रयोग किया है बजाय इसके \nकि यह एक बाइट छोटी है। यदि आप "इसे ऑनलाइन आज़माएं!" लिंक आप देख सकते हैं कि प्रभाव समान है।
— user2390246
डॉस / विंडोज बॉक्स पर, वह न्यूलाइन अभी भी दो (2) बाइट्स होगी। 0x0d0a
— जलाया
10

बैश , 39 38 37 बाइट्स

sed s/[0-9]/duck\\n/g<<<$RANDOM\goose

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

[0,32767] पर समान रूप से वितरित पूर्णांक में अंकों की संख्या के बराबर कई बतख प्रिंट करता है (इसलिए, अधिक बार नहीं, पांच बतख (बतख की एक अच्छी संख्या))।

-1 बाइट के लिए प्रत्येक धन्यवाद @ @ क्रिस और @ उद्धरण चिह्नों के जोड़े को इंगित करते हैं जो अपना वजन नहीं खींच रहे थे।

— सोफिया लेचनर
स्रोत
1
PPCG में आपका स्वागत है!
— स्टैडबॉक्स
1
जब तक आप प्रतिस्थापित \nकरते हैं तब तक आप एकल उद्धरण से छुटकारा पा सकते हैं \\n।
— क्रिस
1
अछा सुझाव। आप बस बैश कंस्ट्रक्शन के साथ कुछ ऐसा कर सकते हैं और 30 बाइट्स के लिए कोई सेड नहीं।
— डिजिटल ट्रामा
1
sed s/[0-9]/duck\\n/g<<<$RANDOM\gooseएक बाइट दाढ़ी कर सकते हैं
— sch
1
sedपूरी तरह से पोर्टेबल नहीं है। कुछ प्लेटफार्मों पर आप सिंगल बैकस्लैश के साथ भाग सकते हैं \n। दूसरों पर आपको कोई नई बात नहीं मिलेगी चाहे आप कुछ भी करें।
— त्रिकाल
9

शुद्ध बैश (कोई बाहरी उपयोगिताओं), 25

@ सोफिया लाइनर के उत्तर के आधार पर , यह अच्छी संख्या में बत्तख भी बनाती है ।

@ OlivierDulac के स्क्रिप्ट शेल PID का उपयोग करने का विचार $पैरामीटर में संग्रहीत 5 बाइट्स बचाता है।

echo "${$//?/duck
}"goose

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

— डिजिटल आघात
स्रोत
1
अगर हम मान लें कि आप एक कार्यक्रम शुरू करते हैं, तो यह हर बार एक अलग तरह का होगा। बहुत समय यह 5 अंक लंबा होगा, लेकिन हमेशा नहीं। इसलिए: 5 बाइट्स दाढ़ी में बदलाव RANDOMकरें; $और एक बत्तख का एक लंबा yes duck|head -n $$;echo goose
— डंडा
@OlivierDulac हाँ, मुझे लगता है कि उपयोग $$स्वीकार्य है - धन्यवाद!
— डिजिटल ट्रॉमा
आपका स्वागत है! मैंने अपना दूसरा संस्करण ( yes duck | head -n $$;echo goose) एक विकल्प के रूप में पोस्ट किया ( आपके मुकाबले लंबे समय तक, लेकिन किसी को 5 अतिरिक्त वर्णों के लिए बतख का एक बहुत मिलता है ^ ^)
— ओलिवियर दुलक
8

बैश + कोरुटिल्स, 36 27 बाइट्स

yes duck|sed $$q;echo goose

प्रिंट बहुत सारे बतख (2 और के बीच cat /proc/sys/kernel/pid_max), फिर एक हंस।

डिजिटल ट्रॉमा और ओलिवियर डुलैक के लिए नौ बाइट्स की बचत की।

इसे ऑनलाइन आज़माएं! (लेकिन ध्यान रखें कि यह कभी-कभार छोटा हो सकता है)

एक ही लंबाई, लेकिन नहीं के साथ echo:

yes duck|sed $${agoose'
q}'

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

aएपेंड कमांड है sed, और qक्विट करता है। दोनों केवल लाइन पर चलते हैं $$, जो पीआईडी ​​से मेल खाती है।

— क्रिस
स्रोत
बैश में मोडुलो है, हालांकि इससे आकार में वृद्धि होगी। कोशिश करेंhead -n $((1+(RANDOM % 5)))
— ट्रिपल
@tripleee चूंकि यह कोड गोल्फ है, इसलिए आउटपुट का आकार बढ़ाना कोड के उस आकार को बढ़ाने के लिए बेहतर है। और १३२ 13६ to बत्तख बिलकुल वाजिब की तुलना में बिलकुल वाजिब है या आप कहीं और देखते हैं;)
— क्रिस
1
निश्चित रूप से, यदि कोई व्यक्ति वास्तव में एक दिन अभ्यास में इस आधारभूत अनुसंधान को लागू करना चाहता है, तो मददगार होने की उम्मीद करना। जैसे, टीआईओ । कुछ स्थानों के साथ 44 बाइट्स निकाले गए।
— त्रिकाल
@OlivierDulac का उपयोग कर सुझाव $$के बजाय $RANDOMके लिए मेरा उत्तर । मुझे लगता है कि आप 5 बाइट्स को बचाने के लिए उसी का उपयोग कर सकते हैं। ओह और कोशिश sedभी करें:yes duck|sed 1$$q;echo goose
— डिजिटल ट्रॉमा
वास्तव yes duck|sed $$q;echo gooseमें ठीक है - मुझे नहीं लगता कि आपकी स्क्रिप्ट को कभी PID <1. मिलेगा
— डिजिटल ट्रॉमा
7

पॉवरशेल , 35 30 28 बाइट्स

,"duck"*((Random)+1)
"goose"

इसे ऑनलाइन आज़माएं! (संशोधित संस्करन)

Get-Randomवस्तुओं की संख्या की एक सरणी उत्पन्न करता है । इसमें समय लग सकता है। यह +1सुनिश्चित करता है कि हम कम से कम एक प्राप्त करें duck। संशोधित संस्करण में एक -maximum ध्वज भी शामिल है 5जिससे आप कार्यक्रम को अपेक्षित रूप से देख सकते हैं (संशोधित संस्करण 1, 2, 3 या 4 ducks पहले प्रिंट होगा goose)।

सरणी और एकान्त gooseस्ट्रिंग को पाइप लाइन पर छोड़ दिया जाता है, और निहितार्थ Write-Outputहमें मुफ्त में नए-अलग मूल्य प्रदान करता है।

आप नहीं जानते कि मेरे लिए "ग्रे डक" को अंतिम पंक्ति में न बदलना कितना मुश्किल था ...

— AdmBorkBork
स्रोत
यह संस्करण बहुत मजेदार लगता है, और निश्चित रूप से एक कोड चुनौती के लायक है ... मैं आपको कुछ दिनों की प्रतीक्षा करने और इसे अपनी खुद की चुनौती के रूप में पोस्ट करने की सलाह देता हूं :)
— AJFaraday
1
@AdmBorkBork, यह मिनेसोटन इस समूह में शामिल हो गया, जो सिर्फ आपके ग्रे डक को +1 कर रहा है।
— मिलवार्डफैन
0..(random)|%{'duck'};'goose'एक 29 की तरह दिखता है, और कहीं-कहीं [int] :: MaxValue (2.1 बिलियन) बकरियों से पहले बत्तख भी पैदा करेगा। (और 0..0एक बतख प्रिंट करता है)
— TessellatingHeckler
@TessellatingHeckler धन्यवाद, लेकिन मैं अभी-अभी 28-बाइट संस्करण के साथ आया हूं। :)
— AdmBorkBork
6

ब्रेकीलॉग , 24 21 बाइट्स

-3 बाइट्स एग्री आफ द आउटॉलफर की बदौलत

"duck"ẉ4ṙ0∧"goose"w∨↰

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

महीने की भाषा के उत्सव में , मेरी पहली ब्रेकीलॉग पोस्ट। इस भाषा में नियंत्रण प्रवाह ठंडा है।

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

"duck"ẉ4ṙ0∧"goose"w∨↰
"duck"ẉ                 print duck with a new line
       4ṙ               choose a random number in the range is [0, 4]
         0              verify it equals zero
          ∧             and (short circuits)
           "goose"w     print goose without a newline
                   ∨    or (if it did not equal zero)
                    ↰   repeat the procedure
— PunPun1000
स्रोत
तो, अगर मैं यह सही पढ़ रहा हूँ, यह बाएँ से दाएँ, नीचे से ऊपर तक पढ़ता है?
— AJFaraday
2
भाषा कार्यक्रम की पहली पंक्ति का उपयोग करके एक तार्किक सत्य खोजने का प्रयास करती है। मेरा कार्यक्रम कहता है "दूसरी पंक्ति को मान्य करें, फिर हंस को प्रिंट करें"। फिर दूसरी पंक्ति कहती है "प्रिंट डक, फिर या तो एक यादृच्छिक संख्या को 0 से 4 तक मान्य करें या फिर इस रेखा को फिर से सत्यापित करें", इसलिए तकनीकी रूप से केवल शीर्ष रेखा के दाईं ओर छोड़ दिया जाता है, फिर कोई भी आपको वहां से कॉल करता है
— PunPun1000
कूल, यह जानना बहुत दिलचस्प है कि नई भाषाएँ कैसे काम करती हैं। यह मेरे इनबॉक्स तक पहुँच गया है, लेकिन मुझे यकीन नहीं है कि अगर यह सवाल है या क्योंकि मैं पहले ही यहाँ टिप्पणी कर चुका हूँ।
— AJFaraday
आप इस तरह दो विधेय को मिला सकते हैं और मुझे बाँध सकते हैं।
— आउटगॉल्फ
6

ज्यामिति डैश वर्ल्ड 2.2 संपादक - 4 ऑब्जेक्ट

ज्यामिति डैश स्तर का चित्र

स्पष्टीकरण:

बीजी ट्रिगर वर्तमान 2.2 का यादृच्छिक ट्रिगर है, इसलिए यह या तो ग्रुप आईडी 1 या 2 को टॉगल करता है।

पहले "DUCK" में 1 की एक समूह आईडी है, जो इसे हटाए जाने या नहीं (toggled) होने की 50% संभावना है।

इस स्तर पर ग्रुप आईडी 2 के साथ कोई वस्तु नहीं है, इसलिए 2 "DUCK" प्रदर्शित होने की 50% संभावना है।

इसे कैसे पुन: प्रस्तुत करें:

पहले "DUCK" में 1 की ग्रुप आईडी है।

यहाँ छवि विवरण दर्ज करें

Goose और 2nd duck में Group ID नहीं है यहाँ छवि विवरण दर्ज करें

यादृच्छिक ट्रिगर के अंदर। यहाँ छवि विवरण दर्ज करें

— MilkyWay90
स्रोत
मुझे इस चुनौती के लिए एक विषय की अनुभूति होती है
— बेंजामिन अर्कहार्ट
@BenjaminUrquhart क्या?
— MilkyWay90
Warcraft के शब्द, Minecraft और कुछ अन्य खेल के लिए प्रस्तुतियाँ भी हैं।
— बेंजामिन यूरेखर्ट
2
@BenjaminUrquhart बेहतर जवाब देने के लिए और अधिक खेल खोजें
— MilkyWay90
5

05AB1E , 15 14 बाइट्स

'Ðœ₁Ωи`.•zíΘ•»

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

2, 5 या 6 बत्तख प्रिंट करेंगे और फिर हंस।

-एक संपीड़ित शब्द (बतख) के लिए @Emigna का उपयोग करके -1 बाइट का धन्यवाद

— Kaldo
स्रोत
1
आप उपयोग कर सकते हैं 'Ðœक्योंकि बतख एक एकल शब्द है।
— एमिग्ना
1
बीट्स मेरा:['ÐœTΩ#].•zíΘ•»
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn मुझे वास्तव में आपका अनंत लूप दृष्टिकोण पसंद है। आपका जवाब निश्चित रूप से चुनौती की भावना में अधिक है (या यह क्या होना चाहिए था?) क्योंकि यह बत्तखों की अनंत मात्रा में उत्पादन कर सकता है।
— कलडो
@ बाल्डो अभी भी, 15 बाइट्स आपके पास खोता है;)
— मैजिक ऑक्टोपस यूरन
1
वैकल्पिक 14-बटर:'Ðœ₁Ω.D.•zíΘ•»
— मैजिक ऑक्टोपस यूरन
5

रेटिना , 17 बाइट्स

?\\K`duck
K`goose

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

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

प्रिंट 1 या 2 बत्तख, समान संभावना के साथ।

व्याख्या

?\\K`duck

काम करने वाले स्ट्रिंग को सेट करें duckऔर इसे अनुगामी लाइनफीड ( \) के साथ प्रिंट करें । फिर इसे दूसरे आउटपुट चरण में लपेटा जाता है, लेकिन इस पर यादृच्छिक फ्लैग ( ?) लगाया जाता है, इसलिए यह केवल 50% की संभावना के साथ प्रिंट करता है।

K`goose

के duckसाथ बदलें goose, जो कार्यक्रम के अंत में स्पष्ट रूप से मुद्रित होता है।

यहां एक मजेदार विकल्प दिया गया है जिसमें 50% संभावना के साथ 1 बतख, 25% के साथ 2 बतख, 12.5% ​​के साथ 3 बतख ...:

\K`duck
?+\G`
K`goose
— मार्टिन एंडर
स्रोत
5

लिनक्स पर विम (स्क्रिप्ट), 46 43 बाइट्स (4946 :लाइन की शुरुआत के साथ )

.!date +0\%N\%s6
s/6.*/goose
s/\d/duck\r/g

के रूप में मार डाला vim -S filenameया चल में चिपकाया vimसाथ :प्रत्येक पंक्ति से पहले।

— jiwopene
स्रोत
2
PPCG में आपका स्वागत है! आप का उपयोग करने के लिए सक्षम होना चाहिए \dसे अधिक [0-9]। इसके अलावा, ऐसा लगता है कि vim को अनुगामी न्यूलाइन की आवश्यकता नहीं है, इसलिए यह 45 बाइट्स हो सकता है :)
— H.PWiz
PPCG में आपका स्वागत है!
— स्टेडीबॉक्स
5

> <> , 31 22 बाइट्स

"duck"a>x
r"esoog"<>o<

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

-9 बाइट्स नहीं एक पेड़ के संशोधन पर आधारित

— KSmarts
स्रोत
1
आप l?!;एक त्रुटि के साथ निकाल और बाहर कर सकते हैं ।
— एमिग्ना
1
और आप कुछ इस
— एमिग्ना
1
या इस तरह ।
— एक पेड़
3
@Notatree मुझे लगता है कि कभी-कभी "\ nkcud \ nkcud ..." प्रिंट होता है। यह शायद ही कभी सही ढंग से व्यवहार करता है
— मान लीजिए
1
@Suppen एक दर्पण के बजाय एक तीर का उपयोग करके इसे ठीक करता है; संपादित देखें।
— केस्मार्ट्स
5

Befunge 98 , 38 30 25 बाइट्स

"esooG"v>:#,_@
"Duck"a<?<

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

  • धन्यवाद @JoKing बेकार trampoline छीनने के लिए
  • छोटी नई लाइन के लिए Befunge 98 पर स्विच करना - अब Duck एक स्ट्रिंग के भीतर फिट बैठता है
— विंसेंट
स्रोत
1
#दूसरी पंक्ति पर आपको जरूरत नहीं है
— जो किंग
और "तकनीकी रूप से", whitespace within a line is fineतो आप कुछ उद्धरणों को काट सकते हैं (भले ही आउटपुट अजीब लगे)
— जो राजा
@JoKing धन्यवाद, मेरा संपादन देखें
— विंसेंट
5

T-SQL , 70 44 43 बाइट्स (कई बतख)

while rand()<.9print'duck'print'duck
goose'

धन्यवाद @Zac फरघेर!

संशोधित संस्करण, 54 43 40 बाइट्स (1 या 2 बतख)

धन्यवाद @BradC!

if rand()<.5print'duck'print'duck
goose'


मैं SQL Fiddle में ठीक से चलाने के लिए इसे प्राप्त नहीं कर सकता , लेकिन यह लाइनक्यूपैड और एसएसएमएस में ठीक काम करता है।

यकीन नहीं होता कि यह एसक्यूएल फिडेल की एक सीमित सीमा है या मैं सिर्फ कुछ गलत कर रहा हूं

— शायद
स्रोत
अच्छा लगा। 61 तक नीचे यदि आप बदल selectजाते हैं printऔर फाइनल 'duck'select'goose'को 'duck(linebreak)goose'(शाब्दिक
— लाइनब्रेक के साथ
दरअसल, आप सिर्फ while rand()<.5print'duck'print'duck(linebreak)goose'43 के लिए कर सकते हैं ।
— ब्राडका
अच्छा लगा, धन्यवाद @ ब्रैडक। क्या तार (13) को जोड़ने के अलावा एक स्ट्रिंग में लाइन ब्रेक का प्रतिनिधित्व करने का एक और तरीका है?
— संभवतः
हाँ, बस सचमुच उद्धरण के अंदर एक वापसी डाल, मैं तुम्हें दिखाने के लिए अपने पोस्ट को संपादित करेंगे (टिप्पणी रिटर्न नहीं दिखाते हैं)।
— ब्रैडेक
1
3 और बाइट्स सहेजें: पहले whileको बदलें if। प्रिंट (बेतरतीब ढंग से) या तो एक बतख या दो, जो (मेरा मानना ​​है) अभी भी चुनौती को संतुष्ट करता है।
— ब्रैड
5

पॉवर्सशेल - 31 30 बाइट्स

चेतावनी : आप सबसे अधिक बतख के साथ समाप्त होने की संभावना रखते हैं।Randomइसमें 0 के मान शामिल Int32.MaxValueहैं, यह इस बात पर निर्भर करता है कि आप कितनी यादृच्छिक संख्या में हैं, यह बहुत बड़ा हो सकता है।

1..(Random)|%{"Duck"};"Goose"
— SomeShinyObject
स्रोत
आप की जरूरत नहीं होनी चाहिए $के सामने (Random)। इसे ऑनलाइन आज़माएं!
— AdmBorkBork
@AdmBorkBork पकड़ने के लिए धन्यवाद!
— SomeShinyObject
4

Befunge

57 35 बाइट्स (पूरे क्षेत्र की परिधि 19x3 17x2 चरचा) सुधार के लिए धन्यवाद।

55+"kcud",,,,,#v?
  @,,,,,"goose"<

दूसरी पंक्ति बतख और स्टैक पर एक नई रेखा (पीछे की ओर) डालती है और इसे एक स्ट्रिंग के रूप में आउटपुट करती है। उसके बाद शुरू में वापस जाने का 75% मौका और फिर से छपाई करने का मौका, 25% (जब प्रश्नचिह्न नीचे जाने का फैसला करता है) हंस को रोकने और रोकने के लिए।

— rael_kid
स्रोत
यदि हंस के लिए 50% मौका स्वीकार्य है, 55+"kcud",,,,,#v?(linebreak here) @,,,,,"goose"< तो आपका कोड 35 बाइट्स तक कट जाएगा
— karhell
आह मीठी लपेटो-चारों ओर। आप सही हैं, धन्यवाद, मैं बाद में अपडेट पोस्ट करूंगा!
— rael_kid
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.