एक शानदार "क्विक ब्राउन फॉक्स" ग्रूवी सर्पिल के साथ "कूद"

Question

परिचय

दिए गए नियमों का पालन करते हुए प्रसिद्ध पैंग्राम के आउटगोइंग सर्पिल को आउटपुट करने के लिए एक प्रोग्राम लिखें।

चुनौती

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

आपका कार्य इस सटीक पाठ का आउटपुट है:

heeeeellllllllllllazzzzzzzzzzz
hummmmmmmmmmmmmppppppppppppppy
hubrrrrrrrrrrrrrrrrrrooooooosy
hukyddddoooooooooooooooggggwsy
hukyveeeeerrrrrrrrrrrrrrrrtwsy
hukyvxjjjjjjjjjjuuuuuuuuuttwsy
hukyvxkbbrrrrrrrrrrrrrrrmttwsy
hukyvxkogggggggttttttttomttwsy
tukyvokoellllllllllllahomttwsy
tukyvokoeovvvvvvvvvvvzhomttwsy
tukyvocoeoummmmmmmmmezhomttwsy
tukyvocoeoufooooooopezhomttwsy
tukyvocohoufroooooxpezhomttwsy
tukyvoiohoufrquuuwxpezhomttwsy
tucyvoiohoufbqttiwxpezhomttwsy
tucyvoiohoufbeehiwxprzhomttwsy
tucyvoiohoufkccciwxprzeomttwsy
tjiyvoidhounnnnnnwxprzeomttwsy
tjiyvoidhojjjjjjjjxprzeomttwsy
tjiyvoidhssssssssssprzeopttwsy
tjiyvoidttttttttttttrzeopttwsy
tjiyvoiyyyyyyyyyyyyyyzqopttwoy
tjiyvouuuuuuuuuuuuuuuuqwpttwoy
tjiyvffffnnnnnnnnnnnnnnwpttwoy
tjiyossssssssssssssssssspthwoy
tjizzzzalllllllllllleeeeehhwoy
tjuuqqqqqqqqqqqqqqqqqeeeeehnod
txxxxxoooooooooooooooffffffnod
reeeeevvvvvvvvvvvvvvvvvvvvvvod
       gggggggoooooooooooooood

यहाँ यह कैसे उत्पन्न होता है,

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

(कहानी कहने के बिना सादा संस्करण)

• प्रसिद्ध पंग्राम "आलसी कुत्ते पर जल्दी भूरे रंग का लोमड़ी कूदता है" को तीन बार दोहराया जाता है, रिक्त स्थान के साथ और निचले मामले में सभी पत्र, उत्पन्न करने के लिए

  thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog
  

• सर्पिल केंद्र से शुरू होता है और "टी" अक्षर से शुरू होता है, यह दाईं ओर जाकर शुरू होता है, और बाहर की ओर दक्षिणावर्त जाता है। यदि वर्तमान वर्ण वर्ण में n-th अक्षर है, तो यह अगले वर्ण पर स्विच करता है जब भी

  • सर्पिल एक कोने तक पहुँचता है, या
  • वर्तमान अक्षर बिल्कुल n बार मुद्रित होते हैं।

इसे बेहतर तरीके से समझाने के लिए, मैं बताऊंगा कि पहले तीन शब्दों "thequickbrown" से संबंधित सर्पिल कैसे उत्पन्न होता है।

 rooooo
 rquuuw
 bqttiw
 beehiw
 kccciw
nnnnnnw

लोमड़ी "टी" से शुरू होती है, दाएं जाती है, 1 कोने तक पहुंचती है, इसे "टी" से पेंट करती है और फिर "एच" पर स्विच करती है और नीचे जाती है, 2 वें कोने तक पहुंचती है, "ई" पर स्विच करती है और बाईं ओर पहुंचती है। तीसरा कोने, "q" पर स्विच करता है और ऊपर जाता है, 4 वें कोने में पहुंचता है, "u" पर जाता है और दाएं जाता है, एक कोने में पहुंचता है और "i" पर स्विच करता है, नीचे जाता है, एक कोने में पहुंचता है और "c" पर स्विच करता है, जाता है बाएं, सफलतापूर्वक अगले कोने पर पहुंचने से पहले 3 "c" s पेंट करता है, "k" पर स्विच करता है और बाईं ओर जाता है, दाएं एक कोने में पहुंचता है, "b" पर स्विच करता है और ऊपर जाता है, पहुंचने से पहले 2 "b" s पेंट करता है अगले कोने, "r" पर स्विच करेंऔर ऊपर की तरफ जाता है , एक कोने तक पहुँचता है और "ओ" पर स्विच करता है, दाएं जाता है, फिर "डब्ल्यू", नीचे, "एन", बाएं।

चश्मा

• आप एक वैकल्पिक इनपुट ले सकते हैं जिसमें स्ट्रिंग का कोई भी मानक रूप हो

  thequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydogthequickbrownfoxjumpsoverthelazydog
  

• आपके आउटपुट को एक स्ट्रिंग के रूप में स्वरूपित किया जाना चाहिए, और फ़ाइलों या STDERR के बजाय STDOUT पर जाना चाहिए, जिसमें नई वर्णमाला सही ढंग से रखी गई हो। खाली लाइनों का शीर्षक और अनुगामी कोई फर्क नहीं पड़ता। प्रत्येक पंक्ति में शीर्ष और अनुगामी रिक्त स्थान की अनुमति है, लेकिन इसके अनुरूप होने की आवश्यकता है। इसलिए यदि आप दिए गए पाठ की एक पंक्ति से पहले 5 रिक्त स्थान जोड़ते हैं, तो आपको प्रत्येक पंक्ति से ठीक 5 स्थान जोड़ना होगा ताकि सर्पिल समान दिखाई दे।

• यह कोड-गोल्फ है , सबसे कम संख्या में बाइट्स जीतती हैं।

• हमेशा की तरह, डिफ़ॉल्ट कमियां यहां लागू होती हैं।

---

_{स्पष्टीकरण का स्वागत है, हालांकि आवश्यक नहीं है।}

_{शीर्षक संपादित करने के लिए इसे एक टिप्पणी के रूप में caird coinheringaahing द्वारा पैंग्राम बनाया जाता है।}

_{आलसी कुत्ता कहानी में प्रकट होने के लिए बहुत आलसी है।}

_{मैं एक ऐसी कड़ी चुनौती तैयार करने का लक्ष्य रख रहा हूं जिसमें निर्देशन के सरल कार्यों द्वारा आउटपुट के लिए पत्र की गणना नहीं की जा सकती।}

Comments

यह शर्म की बात है कि शीर्षक एक पैंग्राम नहीं है

— caird coinheringaahing

@cairdcoinheringaahing अच्छा बिंदु, मैं एक के साथ आने की कोशिश करूँगा। कोई सुझाव?

— वीजुन झोउ

@cairdcoinheringaahing अपडेट

— झोउ

माइनर पॉइंट: पहले 'h' को 't' नहीं, दो बार दोहराया जाना चाहिए?

— मडकिप २०

@ mudkip201 कोने को अगले वर्ण पर स्विच करने से पहले मूल अक्षर के साथ चित्रित किया गया है। शायद मुझे स्पष्ट करना चाहिए।

— वीजुन झोउ

Answer 1

स्टैक्स , 35 34 33 32 बाइट्स

é╛îá%ⁿ┌○iê}→Ug=╩◙╘Ç⌐)QX↑L╓₧╗▌╧▬q

इसे ऑनलाइन चलाएं और डीबग करें

Stax एक ऐसी भाषा है जिस पर मैं लगभग 6 महीने से काम कर रहा हूँ। यह इसके साथ पहला सार्वजनिक गोल्फ है। चलो पहले कारोबार करें।

आमतौर पर प्रिंट करने योग्य ASCII वर्ण सेट में Stax लिखा जाता है। यह 34 बाइट सबमिशन CP437 कैरेक्टर सेट के एक वेरिएंट में पैक किया गया है। इसी ascii प्रतिनिधित्व है

't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr

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

उच्च स्तर पर, यह प्रोग्राम पिछली पंक्ति में बार-बार तार जोड़कर एक ग्रिड का निर्माण करता है। जब अंतिम पंक्ति भर जाती है, तो यह ग्रिड को दक्षिणावर्त घुमाती है। अंत में, यह क्षैतिज रूप से ग्रिड को दर्पण करता है। अधिक विस्तार से, कार्यक्रम इस तरह से काम करता है।

't],{]_96-*~cHT,+nh%^(XUs&xH{rM}MF|<mr
't]                                         ["t"]
   ,                                        Pop from input, push to main ("thequick...")
    {                            F          For each character in input, execute block...
     ]_96-*                                 Produce string using character appropriate
                                                number of times (a=1, b=2, etc)
           ~                                Pop from main, push to input for use later
            cH                              Copy last row from grid.
              T                             Right-trim whitespace
               ,+                           Pop from input stack and append
                 nh%                        Get the width of the first row of the grid
                    ^                       Add 1
                     (                      Right-pad/truncate string to this length
                      X                     Store in the x register
                       Us&                  Overwrite last row of the grid with new value.
                          xH                Get the last element from x.
                                                Basically, the lower right corner.
                             {  }M         Conditionally execute block.  This will happen 
                                                when the bottom right corner isn't a space.
                              rM            Reverse and transpose (aka rotate clockwise)
                                  |<        Left-justify grid; give all rows equal size.
                                     m      For each row, execute the rest of the program
                                               and then print the result to output
                                      r     Reverse the row

Comments

वाह, मैं वास्तव में आश्चर्यचकित हूं कि चुनौती गोल्फिंग भाषा के लिए पहली सार्वजनिक उपस्थिति को देखेगी। आप के सहयोग के लिए बहुत धन्यवाद! महीने की भाषा में रुचि रखते हैं? मैं इसका उपयोग करने वाले और अधिक उपयोगकर्ताओं को देखने की उम्मीद करता हूं और यह जल्द ही उम्मीदवार सूची में दिखाई देता है!

— वीजुन झोउ

@WeijunZhou: तुम्हारा मतलब है यह ? मुझे नहीं पता था कि यह अब तक की बात है। मुझे कोई नामांकन बुरा नहीं लगेगा। ऐसा लगता है कि यह अधिक स्थापित भाषाओं के लिए बेहतर अनुकूल हो सकता है, लेकिन मुझे कोई आपत्ति नहीं है।

— पुनरावर्ती

हाँ। जैसा कि आप कहते हैं, मैं इसे बेहतर तरीके से स्थापित कर सकता हूं। मुझे आशा है कि यह लंबा नहीं होगा।

— वीजुन झोउ

चूंकि "प्रत्येक पंक्ति में हेडिंग स्पेस तब तक मायने नहीं रखता है जब तक वे संगत हैं" यदि आप चाहें तो एक और बाइट बचा सकते हैं।

— वीजुन झोउ

मैंने अभी Stax का उपयोग करके सबमिशन किया है । आप चाहें तो उस पर सलाह दे सकते हैं। संपादित करें: क्या संयोग है। मैं आपके सबमिशन से सीखने की कोशिश करूंगा।

— वीजिन झोउ

Answer 2

चारकोल , 66 40 36 बाइट्स

≔²ηＦＳ«Ｆ¬η«¶↷⊞υη≔⊕÷Ｌυ²η¶»Ｆ⊕⌕βι¿η«≦⊖ηι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: पाठ को इनपुट के रूप में लेकर 16 बाइट्स सहेजे गए। स्पष्टीकरण:

≔²η

tकिसी कारण से 2 एस से शुरू करें ।

ＦＳ«

पैंग्राम में सभी अक्षरों पर लूप।

Ｆ¬η«

क्या हम अभी तक एक कोने में पहुँचे हैं?

¶

नीचे जाएँ (या जो भी अगली दिशा होगी) एक पंक्ति।

↷

90 ° दक्षिणावर्त प्रिंट दिशा घुमाएँ।

⊞υη≔⊕÷Ｌυ²η

अगले पक्ष की लंबाई की गणना करें।

¶»

कर्सर स्थिति को ठीक करना। (चारकोल ने साइड को कोने से ठीक पहले समाप्त करने के लिए पसंद किया होगा, ताकि आप कोने पर ही घूमें।)

Ｆ⊕⌕βι

वर्णमाला में वर्तमान अक्षर की स्थिति के रूप में कई बार लूप।

¿η«

अगर हम कोने तक नहीं पहुंचे हैं,

≦⊖ηι

गिनती को घटाएं और वर्तमान पत्र को प्रिंट करें।

Comments

धन्यवाद। महान काम और अच्छी तरह से समझाया। एक छोटा टाइपो: वहाँ बार -> तीन बार।

— वीजुन झोउ

यह 43 बाइट संस्करण विनिर्देश के अनुसार भी स्वीकार्य है। tio.run/##YY7NTsMwEITPzlNYPW2kcumVExJCikRRhLgBh9Rx4oV4nfon/…

— Weijun Zhou

@ WeijunZhou धन्यवाद, मैंने उस खंड को पहले प्रश्न में नहीं देखा था।

— नील

Answer 3

रूबी , 217 212 209 208 बाइट्स

->s{s+=' '*8
x=0
a=[""]*30
i=14
a[i]=?t
l=->{a[i]=s[x]+a[i]}
r=->{a[i]+=s[x]}
(0..58).map{|g|c=0
(0..g/2).map{c>s[x].ord-97&&(x+=1;c=0)
c+=1
eval %w{r i+=1;r l i-=1;l}[g%4]+"[]"}
x+=1}
a[-1].slice!0
$><<a*$/}

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

समय प्रबंधन बिंदुओं की एक उचित राशि खर्च करता है, इसलिए अधिक गोल्फ के लिए जगह हो सकती है।

-5 बाइट्स: ट्रिपल पैंग्राम से पहले । वेइज़ुन झोउ के लिए धन्यवाद ।

-3 बाइट्स: इनपुट स्ट्रिंग को पैड करें और पिछले पैर को ट्रिम करें, इसके बजाय पिछले पैर को खरोंच से उत्पन्न करें।

-1 बाइट्स: उपयोग करें && एक थकाऊ मूल्य के साथ एक टर्नरी ऑपरेटर के बजाय का ।

स्पष्टीकरण:

->s{
  s += " " * 8                             # These spaces will show on the bottom row
  x = 0                                    # x is a pointer into s
  a = [""] * 30                            # a is an array of row strings
  i = 14                                   # i is a pointer into a
  a[i] = ?t                                # "Starts with two t's for some reason"
  l = ->{ a[i] = s[x]+a[i] }               # lambda to prepend char x to row i
  r = ->{ a[i] += s[x] }                   # lambda to append char x to row i
  (0..57).map{|g|                          # There are 58 "legs" to the spiral
    c = 0                                  # c is the print count of s[x]
    (0..g/2).map{                          # Leg g has g/2+1 characters
      c > s[x].ord-97 && (x+=1;c=0)        # Possibly switch to next letter
      c += 1
      eval %w{r i+=1;r l i-=1;l}[g%4]+"[]" # Call the appropriate lambda
    }
    x += 1                                 # Definitely switch to next letter
  }
  a[-1].slice!0                            # Remove the first char from the bottom row
  $> << a*$/                               # Join with newlines and print
}

Comments

अच्छा प्रस्तुत और स्पष्ट रूप से समझाया। मैं rऔर lलैम्ब्डा के उपयोग की सराहना करता हूं । वर्तमान उत्तरों के आधार पर अंतिम चरण एक परेशानी पैदा करने वाला प्रतीत होता है, हालांकि यह तब नहीं था जब मैंने नमूना आउटपुट उत्पन्न करने के लिए अपना सी स्निपेट लिखा था ...

— वीज़ुन झोउ

ऐसा लगता है कि आप s*=3पूरी तरह से बचा सकते हैं और ऑपरेटर 0में भी छोड़ सकते हैं ?:। tio.run/…

— झोउ

@ WeijunZhou आह, टिप के लिए धन्यवाद। मुझे इसकी आवश्यकता है 0, हालांकि, या रूबी c+=1अगली पंक्ति से ऊपर खींच लेंगे और केवल इसे ज्यादातर समय पर निष्पादित करेंगे । और अच्छी चुनौती!

— benj2240

तुम सही हो। मैं काफी सावधान नहीं दिख रहा था। अपकी प्रशंसा के लिए धन्यवाद। मुझे खुशी है कि आपने इसका आनंद लिया।

— वीजुन झोउ