वह मेरा एक्स नहीं है, उसका वाई भी जेड है


17

यह चुनौती छोटे बच्चों की पुस्तकों की एक श्रृंखला से प्रेरित है जो फियोना वाट और राचेल वेल्स द्वारा लिखी गई है, जिसे मैं हाल ही में अपनी बेटी के साथ आनंद ले रहा हूं।

प्रत्येक पुस्तक में एक माउस (सचित्र, लेकिन पाठ का हिस्सा नहीं) शिकायत करता है कि एक ही प्रकार की 5 चीजों का उत्तराधिकार उसकी चीज नहीं है। इसके बाद यह घोषित करके कि कुछ घटक के पास वह संपत्ति नहीं है जिसकी वह अपेक्षा करता है।

पूछने के छठे समय पर, माउस अपनी चीज पाता है और प्रसन्न होता है क्योंकि उसके पास अपेक्षित संपत्ति होती है।

यहाँ एक विशिष्ट उदाहरण का पाठ है:

That's not my bunny, its tail is too fluffy.
That's not my bunny, its paws are too rough.
That's not my bunny, its tail is too woolly.
That's not my bunny, its eyes are too shiny.
That's not my bunny, its nose is too wrinkled.
That's my bunny! Its ears are so soft.

अब, अधिकांश प्रोग्रामिंग लोक को एहसास होगा कि यह कुछ पाठ के निर्माण की एक बहुत ही एल्गोरिथम विधि है। क्योंकि यह इतनी स्पष्ट प्रक्रिया है, हमें कुछ कोड लिखकर इसे पुन: पेश करने में सक्षम होना चाहिए।

आइए शब्दों के तीन संग्रहों से शुरू करें:

things = ["dinosaur", "lamb", "princess", "reindeer", "train"]
parts = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
properties = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]
  • सबसे पहले, हम तय करते हैं कि हम किस तरह का वर्णन करेंगे।
  • फिर 5 बार, हम लाइन उत्पन्न करेंगे "यह मेरी [चीज] नहीं है, इसका [भाग] बहुत [संपत्ति] है।
  • अंत में, हम लाइन बनाते हैं "यह मेरी [चीज़] है! इसका [भाग] इतना [संपत्ति] है!

चुनौती

  • "यह मेरी नहीं ..." कहानी का पाठ उत्पन्न करें।
  • यह लगातार एक ही पाठ को पुन: पेश नहीं करना चाहिए।
  • यह कोड गोल्फ है, इसलिए कम से कम बाइट्स में ऐसा करने का प्रयास करें।
  • कृपया किसी भी भाषा का प्रयोग करें।
  • व्हाइट स्पेस मायने नहीं रखता है, लेकिन लाइनों के बीच एक नया वर्ण होना चाहिए।
  • स्रोत शब्दों की सूचियाँ आपके उत्तर का हिस्सा नहीं हैं (TIO में उन्हें हेडर में जोड़ा जा सकता है)।
  • आप स्रोत शब्दों की सूचियों का नाम बदल सकते हैं।
  • आउटपुट किसी ऑब्जेक्ट में उत्पन्न टर्मिनल या टेक्स्ट के लिए आउटपुट हो सकता है।
  • कृपया एक ऑनलाइन दुभाषिया का लिंक शामिल करें।
  • पंखुड़ियों को अनदेखा करें, "इसके सींग हैं" ठीक है।
  • यह समझ बनाने की जरूरत नहीं है। यदि आपकी राजकुमारी की फ़नल बहुत अधिक शराबी है, तो बस इतना कहो।

नमूना उत्पादन:

That's not my train, its engine is too rusty.
That's not my train, its hooves is too thick.
That's not my train, its sash is too fuzzy.
That's not my train, its tail is too velvety.
That's not my train, its horns is too glittery.
That's my train! Its hooves is so hairy.

हैप्पी गोल्फिंग!


2
@ शैगी पहला उदाहरण किताबों में से एक का वास्तविक पाठ है। यह इस चुनौती के लिए एक वैध जवाब नहीं है। मैंने कहा है कि चुनौती को आसान बनाने के लिए अपराधों को नज़रअंदाज़ करें। वह उदाहरण मूल रूप से पृष्ठभूमि की जानकारी है।
AJFaraday


10
आप कहते हैं कि "इसका कोई मतलब नहीं है।" (यानी "यह मेरी बन्नी नहीं है, इसकी आँखें बहुत चमकदार हैं। ... यह मेरी बन्नी है! इसकी आँखें इतनी चमकदार हैं।" एक संभावित आउटपुट के रूप में स्वीकार्य है?) - मुझे ऐसा लगता है, बस मैंने सोचा था कि मैं जाँच करूँगा।
जोनाथन एलन

13
"यह लगातार एक ही पाठ को पुन: पेश नहीं करना चाहिए" और असंगत का कोल्लमोगोरोव-जटिलता प्रकार?
जोसेफ सिबल-पुनः मोनिका

2
@ क्रिस यह मेरी टैक्सोनॉमिकल गलती है। हालाँकि दोनों को Glires के रूप में वर्गीकृत किया गया है, इसलिए यह कुछ ऐसा है जिसे मैंने आज सीखा है।
AJFaraday

जवाबों:


1

05AB1E , 63 बाइट्स

ΩU6F€Ω`XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

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

68 बाइट्स संस्करण जो डुप्लिकेट किए गए भागों को आउटपुट नहीं करता है और न ही गुण:

ΩUε.r6£}øεXª`N5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,

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

दोनों कार्यक्रम मानते हैं कि चीजों की सूची पहला इनपुट है, और एक सूची जिसमें भागों की सूची और गुणों की सूची दूसरा इनपुट है।

स्पष्टीकरण:

Ω            # Pop and push a random element of the things-list
 U           # Pop and store it in variable `X`
  6F         # Loop 6 times:
    €Ω       #  Get a random element from both the parts and properties list
      `      #  Push them to the stack
       X     #  And also push variable `X`
             #  (the order on the stack is now: property, part, thing)
    N5Qi     #  If it's the last iteration:
        “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ 
            '#   Push dictionary string "that's my ÿ! its ÿ is so ÿ."
       ë     #  Else:
        “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“
            '#   Push dictionary string "that's not my ÿ, its ÿ is too ÿ."
             #  (where the `ÿ` are automatically replaced with the words on the stack)
       }.ª   #  After the if-else: sentence-capitalize the strings
             #  (so the "That's " as well as the "! Its")
          ,  #  And output it with trailing newline


ΩU           # Pop and store a random thing in variable `X`
  ε          # Map the list of lists of parts/properties to:
   .r        #  Shuffle the list
     6£      #  And leave the first six elements
           # After the map: zip/transpose to create pairs of part & property
    ε        # Foreach over the pairs:
     `XN5Qi“€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“ë“€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“}.ª,
             #  And the rest of the code is the same as above

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों “€Š's€¯ ÿ!€ç ÿ€ˆ€Ê ÿ.“है "that's my ÿ! its ÿ is so ÿ."और “€Š's€–€¯ ÿ,€ç ÿ€ˆ…« ÿ.“है "that's not my ÿ, its ÿ is too ÿ."


10

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

lambda a,*l:shuffle(a)or["That's "+s%(a[0],*map(choice,l))for s in["not my %s, its %s is too %s."]*5+["my %s! Its %s is so %s."]]
from random import*

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

-9 बाइट्स Movatica के लिए धन्यवाद


अच्छा काम! शॉर्टर
ट्यूल

1
@ मोवेटिका ऊह, अच्छा। धन्यवाद!
HyperNeutrino

"यह मेरे हिरन नहीं है, इसके कान बहुत ऊबड़ हैं।" - / के बीच स्विच करने के लिए कुछ चाहिए।
जॉन हंट

1
@ जॉन्हंट नियमों को नियमों की अनदेखी करने के लिए कहते हैं।
हाइपरनेत्रिनो

मेरी गलती। यह v.impressive है
जॉन हंट

8

चारकोल , 72 बाइट्स

≔‽θθF⁵«That's not my θ, its ‽η is too ‽ζ.⸿»That's my θ! Its ‽η is so ‽ζ.

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। चर में होने वाली चीजों, भागों और गुणों की सरणियों की अपेक्षा करता है θ, ηऔर ζ, जो हेडर के बजाय इनपुट में प्रदान करके सबसे आसानी से व्यवस्थित होता है। स्पष्टीकरण:

≔‽θθ

एक यादृच्छिक बात उठाओ।

F⁵«That's not my θ, its ‽η is too ‽ζ.⸿»

पाँच नकारात्मक वाक्य मुद्रित करें।

That's my θ! Its ‽η is so ‽ζ.

सकारात्मक वाक्य को प्रिंट करें।


6

जाप v2.0a0 -R, 73 बाइट्स

ö
6Æ`Tt's {`not `pT=Y<5}my {+`!,`gT} {73dT*H}ts {Vö}  {`tÑ?`ë2!T} {Wö}.

के रूप में तीन सूचियों ले जाता है U, Vऔर W। वे वैसे भी डिफॉल्ट इनपुट वैरिएबल होते हैं, इसलिए केवल तीन सूचियों को इनपुट सेक्शन में रखें।

कोशिश करो

ö                         Saves the random object in variable U
6Æ                        Range [0..6), and map each to the following string
`That's                   The string "That's " plus
{`not `pT=Y<5}            "not " if the index is less than 5 (and store that in variable T), else ""
my                        Literal "my " plus
{+`!,`gT}                 U plus ',' if T, else '!'
{73dT*H}ts                "its " if T, else "Its "
{Vö}                      Random item from V
is                         
{`tsooo`ë2!T}             "too" if T, else "so"
{Wö}.                     Random item from V, plus a period

"बहुत / तो" :) के साथ बहुत अच्छी चाल :)
झबरा

6

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

यह मुख्य कार्यक्रम एक भाग में किसी भी भाग या संपत्ति को नहीं दोहराएगा, और इसका उचित यादृच्छिकरण होगा।

$t=$l|Random
$a=$a|Random -c 6
$r=$r|Random -c 6
0..4|%{"That's not my $t, its $($a[$_]) is too "+$r[$_]}
"That's my $t! Its $($a[5]) is so "+$r[5]

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

get-randomइतनी बार लिखने पर इतने सारे किरदारों पर खर्च होता है! हालाँकि, जब तक आप भागों और संपत्तियों को दोहराया जाने के लिए तैयार नहीं होते हैं, तब तक मैं इसे आगे किसी भी तरीके से सिकोड़ने का तरीका नहीं देख सकता। जब तक आप हेडर में 3 असाइनमेंट लाइनों के अंत में पहली 3 लाइन पाइप को स्थानांतरित नहीं करते हैं। जैसे कुछ होना है

# Header
$l = ("dinosaur", "lamb", "princess", "reindeer", "train")|Get-Random
$a = ("back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows")|sort{Get-Random}
$r = ("bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly")|sort{Get-Random}

# Main
(1..5)|%{echo("That's not my $t, its "+$a[$_]+" is too "+$r[$_])}
"That's my $t! Its "+$a[6]+" is so "+$r[6]

लेकिन ऐसा लगता है कि यह धोखा है, और अभी भी नील के जवाब को हरा नहीं सकता है।

संपादित करें: युक्तियों के लिए धन्यवाद मैट, और थैंक्स एडिंग के लिए AdmBorkBork का धन्यवाद, get-पाठ के 3 सेटों को हटाकर इसे 159 बाइट्स तक कम कर दिया गया, फिर Adm के कुछ और गोल्फ ने इसे 147 पर ला दिया। मैं जिस कोड के बारे में सोच रहा था वह डुप्लिकेट और एक ही गोल्फ टिप्स को लागू करने के बाद विरोधाभासी बयान 144 वर्ण थे

function n{(random 18)+1}
$t=$l[(n)%5]
0..4|%{"That's not my $t, its $($a[(n)]) is too "+$r[(n)]}
"That's my $t! Its $($a[$(n)]) is so "+$r[(n)]

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

हालाँकि, इसमें न केवल एक ही बात को कई बार कहने की प्रवृत्ति होती है, बल्कि इसमें बहुत अधिक आवश्यकता होती है कि आपके इनपुट तत्वों की समान संख्या हो। मेरा मानना ​​है कि छद्म यादृच्छिक संख्या जनरेटर का उपयोग घड़ी पर बहुत अधिक निर्भर करता है, और इसे बार-बार कॉल करने पर अक्सर एक ही परिणाम हो सकता है। फिर यह शर्त है कि यह केवल पूरी सूची का उपयोग करता है यदि सभी सूचियां समान लंबाई हैं। केवल 3 ~ 5 वर्णों की बचत होती है और बहुत सारे कैवेट होते हैं, मैं इस पोस्ट की शुरुआत में कोड पसंद करता हूं।


1
PPCG में आपका स्वागत है! भागों और गुणों को दोहराया जा सकता है ताकि आपको कुछ बाइट्स बचाए जाएं।
झबरा

2
आप Get-से ड्रॉप कर सकते हैं Get-Random। आदेशों का मूल्यांकन करते समय इसकी डिफ़ॉल्ट क्रिया का परीक्षण किया गया।
मैट

2
स्वागत हे! कुछ आसान
गोल्फ


2

जावास्क्रिप्ट, 129

(a,b,c)=>(z='',a.forEach((f,i)=>z+=`That's ${q=i!=5?"not ":""}my ${f}${q?", i":"! I"}ts ${b[i]} is ${q?"to":"s"}o ${c[i]}.\n`),z)

इनपुट तीन सरणियों, रिटर्न स्ट्रिंग है



2

सी # , 204 203 बाइट्स

()=>{int a(int x)=>new Random().Next(x);var j=t[a(5)];string s()=>$"That's not my {j}, its {p[a(25)]} is too {o[a(19)]}.\n";return s()+s()+s()+s()+s()+$"That's my {j}! Its {p[a(25)]} is so {o[a(19)]}.";};

यह इस साइट पर मेरा पहला जवाब है, इसलिए मुझे उम्मीद है कि यह अच्छी तरह से काम करेगा। इसमें उन तीन चीजों की भी जरूरत होती है, लेकिन सवाल के अनुसार जिनकी गिनती नहीं होती है:

   var t = new[] { "dinosaur", "lamb", "princess", "reindeer", "train" };
   var p = new[] {"back", "bells", "body", "bows", "crown", "dress", "ears",
          "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
          "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
          "tiara", "wheels", "windows" };
   var o = new[] {"bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
          "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery",
          "soft", "sparkly", "squashy", "thick", "velvety", "woolly"};

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

एक कम बाइट सोक के लिए धन्यवाद।


1
PPCG में आपका स्वागत है! मैंने आपके उत्तर में TIO की एक कड़ी में संपादन की स्वतंत्रता ले ली है , ताकि अन्य लोग आसानी से आपके लिए अपने कोड की कोशिश कर सकें - मैंने आपको इस टिप्पणी में इसका लिंक दिया होगा, लेकिन URI बहुत लंबे समय से दुर्भाग्य से था! मुझे आशा है कि आप अपने प्रवास का आनंद लेंगे: ओ)
सोक

1
आपके लिए एक छोटा गोल्फ - \rआवश्यक नहीं है, जो आपको 2 बाइट्स बचाएगा।
सोक

1

एपीएल (Dyalog यूनिकोड) , 117 बाइट्स SBCS

↑('That''s not my ',(tT⊃⍨?5),', its ')∘,¨P[5?25],¨' is too '∘,¨V[5?19]
'That''s my ',t,'! Its',P[?25],'is so',V[?19]

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

?N पहले N सूचकांकों के बीच एक यादृच्छिक सूचकांक उत्पन्न करता है।

M?N पहले N सूचकांकों के बीच M यादृच्छिक सूचकांक (प्रतिस्थापन के बिना) उत्पन्न करता है।

, संघटन है

t←T⊃⍨… एक यादृच्छिक चीज़ चुनता है और इसे tअंतिम पंक्ति में पुन: उपयोग के लिए कहता है ।

∘,¨ बाईं ओर स्ट्रिंग को दाईं ओर प्रत्येक स्ट्रिंग में सम्मिलित करता है।

प्रत्येक स्ट्रिंग को बाईं ओर प्रत्येक स्ट्रिंग को दाईं ओर स्थित करता है।

 तार की सूची को एक वर्ण मैट्रिक्स में बदल देता है ताकि यह सही प्रिंट हो जाए।


1

पायथ , 88 78 76 बाइट्स

JONj_ms.ic"That's
 my 

ts 
 is 
o 
."b[?d" not"kJ?d", i""! I"OG?d\s"to"OH)6

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

ऊपर प्रस्तुत कोड के लिए निम्नलिखित शीर्ष लेख की आवश्यकता है:

=N["dinosaur""lamb""princess""reindeer""train")=G["back""bells""body""bows""crown""dress""ears""engine""fan""flippers""funnel""hooves""horns""neck""nose""roof""sash""side""spines""spots""tail""teeth""tiara""wheels""windows")=H["bumpy""fluffy""furry""fuzzy""glittery""glossy""hairy""red""rough""rusty""shiny""silky""slippery""soft""sparkly""squashy""thick""velvety""woolly")

पाइथ के साथ TIO में 'हेडर' फीचर का उपयोग करने के साथ एक छोटी सी समस्या है, क्योंकि ऐसा लगता है कि TIO नए खंडों में कोड ब्लॉक में शामिल होता है, और Pyth में newlines महत्वपूर्ण हैं। यहां आउटपुट में रद्दी लाइन के साथ, 'हेडर' ब्लॉक का उपयोग करके उसी कोड का लिंक दिया गया है।

JONj_ms.ic"That's¶ my ¶¶ts ¶ is ¶o ¶."b[?d" not"kJ?d", i""! I"OG?d"to"\sOH)6   Newlines replaced with ¶
                                                                               Implicit: k="", b=newline
                                                                               From header: N=things, G=parts, H=properties
JON                                                                            Choose a random element from N, store in J
     m                                                                     6   Map [0-6), as d, using:
                                        ?d" not"k                                If d is truthy (i.e. not 0), yield " not", else ""
                                                 J                               J (the chosen thing)
                                                  ?d", i""! I"                   ", i" if d else "! I"
                                                              OG                 Random element from G
                                                                ?d"to"\s         "to" if d else "s"
                                                                        OH       Random element from H
                                       [                                  )      Wrap the previous 6 results in an array
         c"That's¶ my ¶¶ts ¶ is ¶o ¶."b                                          Split the template string on newlines
       .i                                                                        Interleave the template string elements with the previous list
      s                                                                          Concatenate
    _                                                                          Reverse lines
   j                                                                           Join on newlines, implicit print

संपादित करें: गोल्फ को 10 बाइट्स से पुरस्कृत करें, पिछला संस्करण: J+" my "ONV5%"That's not%s, its %s is too %s."[JOGOH;%"That's%s! Its %s is so %s."[JOGOH


1

पर्ल 5.10, 127 बाइट्स

के साथ चला perl -M5.010 -f filename.pl

my @t = qw(dinosaur lamb princess reindeer train);
my @r = qw(back bells body bows crown dress ears engine fan flippers funnel
           hooves horns neck nose roof sash side spines spots tail teeth tiara
           wheels windows);
my @p = qw(bumpy fluffy furry fuzzy glittery glossy hairy red rough rusty shiny
           silky slippery soft sparkly squashy thick velvety woolly);

sub r{rand@_}$a=" my $t[r@t]";say"That's not$a, its $r[r@r] is too $p[r@p]."for(1..5);say"That's$a! Its $r[r@r] is so $p[r@p]."

1

जावास्क्रिप्ट ईएस 6, 149 (+15?) बाइट्स

a = ["dinosaur", "lamb", "princess", "reindeer", "train"]
b = ["back", "bells", "body", "bows", "crown", "dress", "ears",
  "engine", "fan", "flippers", "funnel", "hooves", "horns", "neck",
  "nose", "roof", "sash", "side", "spines", "spots", "tail", "teeth",
  "tiara", "wheels", "windows"]
c = ["bumpy", "fluffy", "furry", "fuzzy", "glittery", "glossy",
  "hairy", "red", "rough", "rusty", "shiny", "silky", "slippery", 
  "soft", "sparkly", "squashy", "thick", "velvety", "woolly"]

// r=x=>x[parseInt(Math.random()*x.length)] 164 for better random on fast pc

r=x=>x[new Date%x.length]
s=r(a)
g=j=>console.log(`That's ${j?`not my ${s}, its ${r(b)} is to`:`my ${s}! Its ${r(b)} is s`}o ${r(c)}.`)
a.map(g) 
g()


कोड गोल्फ में आपका स्वागत है! अच्छा कार्य!
AJFaraday

1
शुक्रिया एजे! स्वागत की सराहना करें :)
Onitz

1

बैच फ़ाइल, 434 424 + 7 बाइट्स

के माध्यम से निष्पादित cmd/q/c

कोड नहीं गिना गया

set a=dinosaur lamb princess reindeer train
set b=back bells body bows crown dress ears engine fan flippers funnel hoobes horns neck nose roof sash side spines spots tail teeth tiara wheels windows
set c=bumpy fluffy furry fizzy glittery glossy hair red rough rusty shiny silky slippery soft sparkly squashy thick velvety woolly

कोड गिना गया

set q=random
set m=set/ar=1+%%%q%%%%%%%
call %m%5
for /f "tokens=%r%" %%x in ("%a%")do set x=%%x
:a
set/ad+=1
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.
if %d% neq 5 goto a
call %m%25
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
call %m%19
for /f "tokens=%r%" %%z in ("%c%")do echo That's my %x%! Its %y% is so %%z.

मैं कुछ चुनौतियों से गुज़रूँगा, जिनका आपको सामना करना चाहिए और समझाना / बताना चाहिए कि मैंने ऐसा क्या किया जिससे दूसरों में सुधार हो सके।

उस सरणी से एक यादृच्छिक तत्व चुनें, जो
मैंने इसके बीच एक यादृच्छिक संख्या उत्पन्न करके किया था 1और उस सरणी में तत्वों की मात्रा nकहां nहै। मैंने तब इस रैंडम नंबर का उपयोग प्रत्येक forलूप ( tokens=%r%) में हड़पने के लिए टोकन के रूप में किया था । क्योंकि मैंने इसे इस तरह से किया था, मैं forअब इन छोरों को घोंसला नहीं दे सकता tokens=!r!था , जैसा कि मेरे लिए काम नहीं कर रहा था (विलंबित विस्तार के साथ)। यह काफी कुछ बाइट्स बचा सकता है क्योंकि यह टोकन को चर के रूप में बचाने की आवश्यकता को हटा देगा (set x=%%x )।

रैंडम नंबर जेनरेशन
m मेरी रैंडम नंबर जेनरेशन मैक्रो है। इसे इस तरह से करने से set/ar=%random%%%n+1हर लाइन की तरह 32 बाइट्स बचती हैं । आप अर्द्ध धोखा और तय करते हैं कि टोकन सकता है yऔर zएक ही तत्व होने के लिए कर रहे हैं:

call %m%19
for /f "tokens=%r%" %%y in ("%b%")do set y=%%y
for /f "tokens=%r%" %%z in ("%c%")do echo That's not my %x%, its %y% is too %%z.

यह, जबकि अभी भी कुछ यादृच्छिकता को बनाए रखते हुए, अंतिम 6 तत्वों को बाहर करेगा c। इससे न्यूनतम 20 बाइट बचती हैं, लेकिन मुझे नहीं लगता कि यह ऑप की आवश्यकताओं के लिए सच है।

सैद्धांतिक सुधार
मैंने इस "छद्म-कोड" को बनाने के प्रयास में काफी समय बिताया, जबकि अभी भी बाइट्स बचा रहा है:

set 1-5=echo That's not my %x%, its %y% is too %%z.
set 6=echo That's my %x%! Its %y% is so %%z.
...
set/ad+=1
for /f "tokens=%r%" %%z in ("%c%")do call %%d%%

दुर्भाग्य से इसके लिए सेटअप लाभदायक होने के लिए बहुत सारे बाइट्स लेने के लिए साबित हो रहा है (<144 बाइट्स में लागू करना पड़ता है) लेकिन मैं इस भावना को हिला नहीं सकता कि कोड की अंतिम 4 पंक्तियों को जोड़ना बहुत ही शानदार और जानदार है।


आपको पूर्व-निर्धारित चर के माध्यम से इनपुट लेने की अनुमति नहीं है। आपको इसे किसी भी मानक IO विधियों के
Jo King

1
@JoKing चुनौती से:The lists of source words are not part of your answer (in TIO they can be added to the header).
AdmBorkBork

मैं अनिश्चित हूं कि इसकी अनुमति है या नहीं, जैसा कि मैंने इसे अन्य उत्तरों में दोनों तरीके से देखा है, लेकिन आप में से उत्सुक लोगों के लिए यह मेरे जवाब में 29 बाइट्स जोड़ देगा set a=%~1, आदि
बीडीएम

1

स्याही , 119 बाइट्स

~a=LIST_RANDOM(a)
-(l)That's{l<6: not} my {a}{l<6:, i|! I}ts {LIST_RANDOM(b)} is {l<6:to|s}o {LIST_RANDOM(c)}
{l<6:->l}

के रूप में परिभाषित सूचियों के साथ

LIST a=(dinosaur),(lamb),(princess),(reindeer),(train)
LIST b=(back),(bells),(body),(bows),(crown),(dress),(ears),(engine),(fan),(flippers),(funnel),(hooves),(horns),(neck),(nose),(roof),(sash),(side),(spines),(spots),(tail),(teeth),(tiara),(wheels),(windows)
LIST c=(bumpy),(fluffy),(furry),(fuzzy),(glittery),(glossy),(hairy),(red),(rough),(rusty),(shiny),(silky),(slippery),(soft),(sparkly),(squashy),(thick),(velvety),(woolly)

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


हालांकि एक सूची के रूप में क्या मायने रखता है, इसके आधार पर अन्य दृष्टिकोण हैं। यदि एक सूची एक फ़ंक्शन हो सकती है जो किसी सूची आइटम को बेतरतीब ढंग से वापस करती है, तो निम्न दृष्टिकोण केवल 91 बाइट्स है:

~temp t=u()
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {p()} is {l<6:to|s}o {q()}
{l<6:->l}

("सूचियों" के साथ निम्नानुसार परिभाषित)

==function u
~return "{~dinosaur|lamb|princess|reindeer|train}"
==function p
~return "{~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows}"
==function q
~return " {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}."

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


निम्नलिखित दृष्टिकोण भी है।

~temp t="{~dinosaur|lamb|princess|reindeer|train}"
-(l)That's{l<6: not} my {t}{l<6:, i|! I}ts {~back|bells|body|bows|crown|dress|ears|engine|fan|flippers|funnel|hooves|horns|neck|nose|roof|sash|side|spines|spots|tail|teeth|tiara|wheels|windows} is {l<6:to|s}o {~bumpy|fluffy|furry|fuzzy|glittery|glossy|hairy|red|rough|rusty|shiny|silky|slippery|soft|sparkly|squashy|thick|velvety|woolly}
{l<6:->l}

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

यह समाधान 389 बाइट्स है, लेकिन यदि फेरबदल शाब्दिक (जो इस परिदृश्य में वास्तव में स्थानांतरित नहीं किया जा सकता है) को सूची परिभाषाओं के रूप में गिना जाता है और बाइट गिनती से बाहर रखा जा सकता है, यह 80 बाइट्स तक गिर जाता है।


0

बैश + जाग, 209 बाइट्स

T=$(shuf $1|head -1)
join <(sed "s/.*/$T\t&/" $2) <(sed "s/.*/$T\t&/" $3)|shuf|awk 'NR<6{printf "That'\''s not my %s, its %s is too %s.\n",$1,$2,$3}NR==6{printf "That'\''s my %s! Its %s is so %s.\n",$1,$2,$3}'

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

इनपुट को स्वीकार करता है, things parts propertiesजहां प्रत्येक वांछित प्रकार की एक पंक्ति प्रति आइटम के साथ एक फ़ाइल है।

यह एक फ़ाइल-केंद्रित दृष्टिकोण है। बाद में यह देखने के लिए कि क्या इसे बेहतर बनाया जा सकता है, एक सरणी-केंद्रित दृष्टिकोण का प्रयास करें।


-2

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

अपनी आवश्यकताओं को शाब्दिक रूप से लेना, और गाड़ी का रिटर्न एक-एक बाइट लेना:

y=0
def x():
    global y
    y=1-y 
    print(("That's not my lamb, it's "+b[0:1][y]+" is too red\n")*5+"That's my lamb! Its fan is so red")

"यह लगातार एक ही पाठ को पुन: पेश नहीं करना चाहिए।" मैं जो बता सकता हूं, उससे आपका कोड हमेशा दो विकल्पों में से एक के बीच वैकल्पिक होगा, जो मुझे लगातार आउटपुट की तरह लगता है। साथ ही, प्रत्येक एकल पंक्ति पर समान गुणों का हमेशा उपयोग करने का यह मामला टिप्पणी स्पष्टीकरण में स्पष्ट रूप से अस्वीकृत हो गया है।
मूल्य इंक
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.