ब्लूप्रिंट ए सेस्टिना

Question

एक सेस्टिना कविता का एक प्रारूप है जो एक दिलचस्प पैटर्न का अनुसरण करता है जिसे हम उत्पन्न कर सकते हैं। इसमें छः पंक्तियों के छह छंद हैं, जहाँ पहले छंद में प्रत्येक पंक्ति के अंतिम शब्द प्रत्येक क्रमिक छंद में पंक्ति के अंत को बनाते हैं, एक सेट पैटर्न में घुमाया जाता है। (अंत में एक तीन पंक्ति का श्लोक भी है, लेकिन हम इसके बारे में चिंता नहीं करेंगे।) एलिजाबेथ बिशप के रचनात्मक रूप से सेस्टिना नाम के पहले तीन श्लोक पर एक नज़र डालें :

सितंबर की बारिश घर पर आती है।
असफल प्रकाश में, बूढ़ी दादी लिटिल मार्वल स्टोव के बगल में
बच्चे के साथ रसोई में बैठती है , पंचांग से चुटकुले पढ़ती है, हंसती है और अपने आँसू छिपाने के लिए बात करती है।

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

अभी चाय का समय है; लेकिन बच्चा गर्म काले चूल्हे पर पागल की तरह
टीकेटे के छोटे कठिन आँसू
नृत्य देख रहा है ,
जिस तरह से बारिश को घर पर नृत्य करना चाहिए।
तंग आकर, बूढ़ी दादी
ने चालाक पंचांग को लटका दिया

...

ध्यान दें कि प्रत्येक पंक्ति छह शब्दों में से एक के साथ कैसे समाप्त होती है "घर," "दादी," "बच्चा," "चूल्हा," "पंचांग," या "आँसू।" इतना ही नहीं, लेकिन शब्द पिछले छंद के सापेक्ष 6–1–5–2–4–3 पैटर्न में दिए गए हैं। यह एक सर्पिल की तरह लग रहा है:

हम अभी भी प्रोग्रामेटिक रूप से एक पूर्ण सेस्टिना उत्पन्न करने से कुछ साल दूर हैं, लेकिन हम उचित क्रम में प्रत्येक श्लोक के अंतिम शब्दों की विशेषता वाला एक टेम्पलेट बना सकते हैं। एक प्रोग्राम या फ़ंक्शन लिखें, जो छह लाइन समाप्त करने वाले शब्दों को देखते हुए, इन नियमों का पालन करते हुए एक सेस्टिना के लिए खाका तैयार करता है। यहाँ इनपुट के लिए अपेक्षित परिणाम है house grandmother child stove almanac tears:

house
grandmother
child
stove
almanac
tears

tears
house
almanac
grandmother
stove
child

child
tears
stove
house
grandmother
almanac

almanac
child
grandmother
tears
house
stove

stove
almanac
house
child
tears
grandmother

grandmother
stove
tears
almanac
child
house

पहला श्लोक मूल क्रम में शब्द है, दूसरा श्लोक पहले से 6-1-5-2-4-3 क्रम में है। तीसरा श्लोक वह क्रम है जो दूसरे के सापेक्ष है, और इसी तरह, श्लोक 6 के लिए सभी तरह से।

मान लें कि इनपुट शब्द हमेशा केवल अक्षर, अपरकेस या लोअरकेस होंगे। आप उन्हें एक स्ट्रिंग के एक सरणी के रूप में ले सकते हैं या एक गैर-अक्षर वर्ण (स्थान, नई रेखा, आदि) द्वारा सीमांकित एक स्ट्रिंग है। आउटपुट में, लाइनें newlines ( 0x0A) से अलग हो जाती हैं, और स्टैंजस दो newlines द्वारा अलग हो जाते हैं। एक अनुगामी न्यूलाइन स्वीकार्य है।

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

Comments

अनुगामी न्यूलाइन्स स्वीकार किए जाते हैं?

— लुइस मेंडो

इसके अलावा, क्या विभाजक रेखा में स्थान हो सकता है?

— लुइस मेंडो

@LuisMendo ज़रूर, दोनों ठीक हैं।

— निंजाबियरनॉकी

क्या आउटपुट स्ट्रिंग्स की ऑर्डर की गई सूचियों की एक आदेशित सूची हो सकती है?

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

Sestinas के लिए +1, लेकिन मुझे यकीन नहीं है कि यह natural-languageटैग का गुण है । एल्गोरिथ्म एक ही है भले ही इनपुट जिबरिश के छह तार हो।

— DLosc

Answer 1

जेली , 15 14 बाइट्स

620œ?$ÐĿY€j⁷Ḥ¤

TryItOnline!

कैसे?

हाँ, जेली के लिए मेरे अतिरिक्त में से एक का उपयोग! ( œ?)

620œ?$ÐĿY€j⁷Ḥ¤ - Main link: list of words L
      ÐĿ       - loop until no longer unique, collecting intermediate results
     $         -     last two links as a monad
   œ?          -         permutation of right argument (initially L) at index
620            -         620
        Y€     - join with line feeds for €each (the words of each stanza)
          j    - join (the stanzas) with
             ¤ - nilad followed by link(s) as a nilad
           ⁷   -     a line feed
            Ḥ  -     double (two line feeds)

Answer 2

पायथन, 72 64 बाइट्स

i,n=input(),'\n';exec"print n.join(i)+n;i=map(i.pop,[-1,0]*3);"*6

एसटीडीआईएन के माध्यम से इनपुट को 6 स्ट्रिंग्स के एक अलग-अलग सरणी के रूप में ले जाता है और पोस्ट में वर्णित प्रारूप में एक अतिरिक्त अनुगामी न्यूलाइन के साथ एसटीडीयूटी को अलग कर देता है।

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

इसके अलावा, मुझे यकीन नहीं है कि यह करना ठीक है, लेकिन यहां 59 बाइट्स में एक अनाम लंबो फ़ंक्शन के रूप में एक छोटा जवाब है जो उपरोक्त उत्तर के समान प्रारूप में इनपुट लेता है, और उत्पन्न करने के लिए आवश्यक प्रोग्राम को आउटपुट करता है। सही उत्पादन:

lambda i,n='\n':"print n.join(i)+n;i=map(i.pop,[-1,0]*3);"*6

इसलिए इसे प्रारूप में कहा जाना चाहिए exec(<Function Name>(<Array>))। फिर, मुझे यकीन नहीं है कि यह करना ठीक है, इसलिए मैं इसे एक अतिरिक्त, अलग, गैर-प्रतिस्पर्धात्मक उत्तर के रूप में जोड़ रहा हूं जब तक कि कोई (शायद ओपी) भी उम्मीद कर सकता है कि यह ठीक है या नहीं, जो मैं वास्तव में सराहना करूंगा ।

Comments

मुझे popतरकीब पसंद है !

— xnor

Answer 3

MATL , 18 17 बाइट्स

0ch5:"t[6l5H4I7])

इनपुट स्वरूप में स्ट्रिंग का एक सेल सरणी है

{'house' 'grandmother' 'child' 'stove' 'almanac' 'tears'}

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

व्याख्या

0c          % Push string with a single space, to be used as separator
h           % Input array of 6 strings implicitly and append the above string
5:"         % Repeat 5 times
  t         %   Duplicate the array of strings (previous stanza plus separator)
  [6l5H4I7] %   Push array [6 1 5 2 4 3 7]. The 7th string is the separator, and stays
            %   at the end. The other strings are shuffled as required
  )         %   Index into the array of strings
            % End implicitly
            % Display implicitly

Answer 4

गणितज्ञ, 59 बाइट्स

r=Riffle;""<>Flatten@r[NestList[RotateRight,#,5],""]~r~"\n"&

इस अनाम फ़ंक्शन का मूल है NestList[RotateRight,#,5], जो लंबाई 6 की इनपुट सूची बनाता है और 6 सूचियों की एक सूची बनाता है, प्रत्येक को सेस्टिना तरीके से घुमाया जाता है। वास्तव में, यदि सूचियों की सूची स्वीकार्य आउटपुट है, तो 26 बाइट्सNestList[RotateRight,#,5]& में काम करता है ।

फिर, r[...,""]प्रत्येक 6 सूचियों के बीच एक खाली स्ट्रिंग सम्मिलित करता है; Flattenतार की एक सूची में पूरी बात बदल जाती है; ~r~"\n"फिर उनमें से प्रत्येक तार के बीच एक नई रेखा सम्मिलित करता है; और ""<>पूरी बात को एक ही तार में समेट देता है। इस प्रकार अन्य 33 बाइट्स केवल संरचित आउटपुट को एक स्ट्रिंग में बदलने के लिए हैं।

Answer 5

बैच, 99 बाइट्स

@for %%w in (%*)do @if not .%%w==.%7 echo %%w
@echo(
@if not .%7==...... %0 %6 %1 %5 %2 %4 %3 .%7

स्पष्टीकरण: कमांड-लाइन मापदंडों के रूप में इनपुट लेता है। मूल रूप से खाली 7 वें पैरामीटर में एस %0जमा करते हुए, इसे चारों ओर लूप करने का कारण बनता है .। अतिरिक्त .इसलिए है क्योंकि ifखाली तारों पर काम नहीं करता है।

Answer 6

रूबी, 51 बाइट्स

->z{z.map{z[1],z[3],z[5],z[4],z[2],z[0]=z+[""]}*$/}

0..5नीचे दिए गए नंबरों पर पुनरावृति के बजाय , हम 6 बार दोहराते हैं z। सामान्य उपयोग में जैसे (0..5).map{|i|puts i}कि कोड {}पढ़े गए तत्वों को पुनरावृत्त करता है। इस मामले में कोड के अंदर किए गए क्रमपरिवर्तन {}ओवररेटेड तत्वों को नहीं पढ़ते हैं, इसलिए हम zक्रमपरिवर्तन के बिना इस हस्तक्षेप के तत्वों पर पुनरावृति कर सकते हैं।

रूबी, 56 बाइट्स

एक पैरामीटर के रूप में एक 6 तत्व सरणी लेता है

->z{(0..5).map{z[1],z[3],z[5],z[4],z[2],z[0]=z+[""]}*$/}

6 मापदंडों को लेते हुए वैकल्पिक संस्करण

->a,b,c,d,e,f{(0..5).map{b,d,f,e,c,a=a,b,c,d,e,f,""}*$/}

mapहम अनुमति के प्रत्येक पुनरावृत्ति के साथ z। मूल संस्करण के साथ-साथ एक ""श्लोक के बीच एक विराम का प्रतिनिधित्व करने के लिए आउटपुट बन जाता है map(यह सातवें सरणी तत्व की आवश्यकता नहीं है इसलिए असाइनमेंट को अनदेखा किया जाता है)। *$/सरणियों को एक स्ट्रिंग में कनवर्ट करता है, सब कुछ को एक साथ जोड़कर नए सिरे से बनाता है।

Answer 7

रैकेट 115 बाइट्स

(let p((o(list l))(m 0))(if(> n m)(p(cons(map(λ(x)(list-ref(list-ref o 0)x))'(5 0 4 1 3 2))o)(+ 1 m))(reverse o)))

Ungolfed:

(define(f l n)
 (let loop ((ol (list l))
             (m 0))
    (if (> n m) 
        (loop
         (cons (map
                (λ (x) (list-ref (list-ref ol 0) x))
                '(5 0 4 1 3 2))
               ol)
         (add1 m))
        (reverse ol))))

परिक्षण:

(f (list "house" "grandmother" "child" "stove" "almanac" "tears") 6)

आउटपुट:

'(("house" "grandmother" "child" "stove" "almanac" "tears")
  ("tears" "house" "almanac" "grandmother" "stove" "child")
  ("child" "tears" "stove" "house" "grandmother" "almanac")
  ("almanac" "child" "grandmother" "tears" "house" "stove")
  ("stove" "almanac" "house" "child" "tears" "grandmother")
  ("grandmother" "stove" "tears" "almanac" "child" "house")
  ("house" "grandmother" "child" "stove" "almanac" "tears"))