अमेरिका पर चढ़ो

Question

अब जब अन्य उपयोगकर्ताओं ने ट्रम्प को दीवार बनाने में मदद की है, तो आपके पास इसे चढ़ने का समय है।

यह एक आस्की कला चुनौती है जहां आपको एक चढ़ाई वाली दीवार को बेतरतीब ढंग से रखने के साथ उत्पादन करने की आवश्यकता होती है।

एक चढ़ाई वाली दीवार पैनलों से बनी होती है, जिनमें से प्रत्येक 3 से 10 होल्ड के बीच होती है और 5 पैनल ऊँची होती है। प्रत्येक पैनल 4 वर्ण ऊंचे और 10 वर्ण पार हैं

हम |दीवार (बगल) -के किनारे और पैनलों के किनारों का प्रतिनिधित्व करने के लिए उपयोग करते हैं। पैनलों के कोनों द्वारा दिखाया गया है +और धारण के रूप में दिखाया गया है o।

अंत में, दीवार को America!सबसे ऊपर और Mexicoसबसे नीचे होना चाहिए ।

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

यह एक उदाहरण आउटपुट है:

  America!
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
   Mexico

यह भ्रामक रूप से सेट किया जा सकता है इसलिए यह नीचे स्पष्ट रूप से संरचित है

इनपुट

Zilcho। आपको बिलकुल इनपुट नहीं लेना चाहिए।

उत्पादन

5 पैनल से बनी एक अस्सी-आर्ट क्लाइम्बिंग दीवार, प्रत्येक एक 6 लाइनों को 12 स्तंभों के साथ America!शीर्ष Mexicoपर और नीचे की ओर केंद्रित किया गया। प्रत्येक पैनल में एक समान पैटर्न होता है जो प्रोग्राम द्वारा यादृच्छिक रूप से उत्पन्न होता है। पैनल पैटर्न में 3 और 10 के बीच एक बेतरतीब ढंग से वितरित यादृच्छिक संख्या होती है।

नियम

• किसी इनपुट की अनुमति नहीं है
• मैं कहूंगा कि "कोई निर्माण नहीं" लेकिन अगर आपकी भाषा में इसके लिए एक बिलिन है, तो मैं इसे स्वचालित रूप से विजेता के रूप में स्वीकार करूंगा।
• यह कोड-गोल्फ है इसलिए सबसे छोटा कोड (बाइट्स में) जीतता है।
• बिना होल्ड के आउटपुट बिलकुल वैसा ही होना चाहिए, जैसा कि बिना होल्ड के फिर से।
• रैंडम यहाँ परिभाषित यादृच्छिक है

Comments

क्या यादृच्छिक का मतलब समान रूप से यादृच्छिक है, या क्या प्रत्येक संभावित लेआउट को बस होने की एक गैर-शून्य संभावना की आवश्यकता होती है, या क्या मुझे कम से कम दो संभावनाएं होने की आवश्यकता है?

— पावेल

@ Notts90 वे समान होने चाहिए, और एक मात्रा अनियमित रूप से चुनें। इस पोस्ट में उल्लेख किया गया है, लेकिन यादृच्छिकता परिभाषित नहीं है।

— पावेल

मुझे अभी भी लगता है कि यह बेहतर चुनौती होगी अगर हर पैनल को अलग होना चाहिए।

— झबरा

यह यहीं सैंडबॉक्स के साथ मेरा मुद्दा है। मुझे एक महीने से अधिक समय से यह चुनौती थी और मैंने अभी अपने पदों को खाली करने का फैसला किया है। इसलिए मैं यह सोचकर यह पोस्ट करता हूं कि हर मुद्दे को हवा दी गई है और ऐसा होता है!

— 17'14

@WORNALL फेक न्यूज़! झूठ! यादृच्छिक बहुत महत्वपूर्ण है। ट्रम्पस्क्रिप्ट में सबसे अच्छी रैंडम जनरेटर है जिसे आपने कभी देखा है। (आपको बस इतना करना है कि राष्ट्रपति के ट्विटर फीड से लिंक है!)

— लेवल रिवर सेंट

Answer 1

जेली , 65 57 बाइट्स

पहली बार नए फंगेल का उपयोग ⁽, दो-कोड-पॉइंट पूर्णांक स्ट्रिंग शाब्दिक ( ⁽¥0= 2049)

⁽¥0ṃ⁾+-W
“K2X)»Ṅø40RẊ<8X+3¤s⁵ị⁾o j@€⁾||Yṭ¢µṄ€5¡Ṗ;⁷“Ç€:;#»

पूर्ण कार्यक्रम कोई इनपुट नहीं ले रहा है और दीवार को प्रिंट कर रहा है।

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

कैसे?

⁽¥0ṃ⁾+-W - Link 1, panel separator: no arguments
⁽¥0      - literal 2049
    ⁾+-  - literal "+-"
   ṃ     - convert 2049 to base "+-" as if they were [1,0]
       W - wrap in a list   -> ["+----------+"]

“K2X)»Ṅø40RẊ<8X+3¤s⁵ị⁾o j@€⁾||Yṭ¢µṄ€5¡Ṗ;⁷“Ç€:;#» - Main link: no arguments
“K2X)»                                           - "  America!"
      Ṅ                                          - print with line feed
       ø                                         - niladic chain separation
        40                                       - literal 40
          R                                      - range -> [1,2,...,40]
           Ẋ                                     - random shuffle
                 ¤                               - nilad and link(s) as a nilad:
             8X                                  -   random integer between 1 and 8
                3                                -   literal 3
               +                                 -   add
            <                                    - less than? (vectorises)
                   ⁵                             - literal 10
                  s                              - split into chunks of length 10
                     ⁾o <-- a space              - literal "o "
                    ị                            - index into
                           ⁾||                   - literal "||"
                        j@€                      - join with reversed @rguments
                              Y                  - join with line feeds
                                ¢                - call last link (1) as a nilad
                               ṭ                 - tack left to right
                                 µ               - call that p... (monadic chain separation)
                                    5¡           - repeat five times:
                                   €             -   for €ach (separator & panel)
                                  Ṅ              -     print with trailing line feed(separator and panel):
                                      Ṗ          - pop (just the separator now)
                                        ⁷        - literal line feed
                                       ;         - concatenate
                                                 - unused value printed
                                         “Ç€:;#» - "   Mexico"
                                                 - implicit print

Comments

यह अब तक का सबसे लंबा जेली कार्यक्रम है।

— पावेल

अस्पष्टता बदल दी गई है। मैंने 3-10 के साथ फैसला किया कि मैं तुम्हें रहने दूंगा।

— केयर्ड सिक्काहिंगाहिंग

के लिए +1 )o <-- a space। वास्तव में मुझे हँसाया!

— caird coinheringaahing

@Phoenix छोटा हो गया है, लेकिन मैं मदद नहीं कर सकता लेकिन लगता है कि यह अभी भी कम होना चाहिए।

— जोनाथन एलन

@ शैतान का यह लगभग एक अंतरिक्ष-कूदनेवाला है!

— जोनाथन एलन

Answer 2

PHP, 138 बाइट्स

<?=($p=str_pad)("  America!",349,strtr("
+----------+
|0|
|1|
|2|
|3|",str_split(str_shuffle($p($p(o,rand(3,10),o),40)),10)))."   Mexico";

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

विस्तारित

<?=($p=str_pad)("  America!",349, 
#fill the string till a length of 349 with
strtr("
+----------+
|0|
|1|
|2|
|3|",
# before replace the digits with strings in the array
str_split(str_shuffle($p($p(o,rand(3,10),o),40)),10))) 
# make a string with o length 3- 10 fill it with spaces to length 40
# shuffle the resulting string and split it into a array of strings with length 10
."   Mexico"; # add the end

Answer 3

जावास्क्रिप्ट (ईएस 6), 194 160 बाइट्स

(h=0,g=p=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s])))=>`  America!
${t=`+----------+
`}${g(`|          |
`.repeat(4)+t).repeat(5)}   Mexico`

---

कोशिश करो

नीचे दिए गए स्निपेट में हर 2 सेकंड में होल्ड का पैटर्न बदल जाएगा।

f=
(h=0,g=p=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s])))=>`  America!
${t=`+----------+
`}${g(`|          |
`.repeat(4)+t).repeat(5)}   Mexico`
o.innerText=f()
setInterval("o.innerText=f()",2e3)

<pre id=o>

---

व्याख्या

• हम एक अनाम फ़ंक्शन बनाते हैं, जो, हालांकि यह कोई इनपुट नहीं लेता है, जिसमें डिफ़ॉल्ट मानों के साथ 2 पैरामीटर हैं:
  • h, जिसका आरंभिक मूल्य दिया जाता है 0 ; जब हम उन्हें जोड़ने के लिए जाते हैं, तो यह पैनल पर होल्ड की संख्या की गिनती रखेगा।
  • g, जो एक पुनरावर्ती कार्य है जिसका उपयोग हम पैनल पर होल्ड के यादृच्छिक पैटर्न को बनाने के लिए करेंगे। हम इसे थोड़ा सा वापस करेंगे।
• मुख्य फ़ंक्शन बॉडी में, हम एक टेम्पलेट शाब्दिक आउटपुट देते हैं, जिसके साथ शुरू होता है America!\n ।
• हम तब पैनल डिवाइडर ( +----------+\n) बनाते हैं और इसे वेरिएबल में असाइन करते हैंt में नियत करते हैं, इसे प्रक्रिया में आउटपुट में जोड़ते हैं।
• अगला, हम पैनल की एक पंक्ति बनाते हैं ( | |\n), इसे 4 बार दोहराएं और संलग्न करेंt ।
• हम कॉल करते हैं g, स्ट्रिंग को एक तर्क के रूप में ऊपर पैरामीटर से गुजरते हुएp ।
• अब, पकड़ पैटर्न के लिए। अंदरg :
  • हम यह देखने के लिए जाँच करते हैं कि क्या h>2 (यानी, हमारे पास 3 या अधिक होल्ड हैं)।
  • यदि हां, तो हम स्ट्रिंग लौटाते हैं p।
  • यदि नहीं, तो हम gफिर से कॉल करते हैं, इस बार pतर्क के रूप में एक संशोधित प्रतिलिपि पास कर रहे हैं।
  • की संशोधित प्रतिलिपि pहै replaceउस पर प्रयोग विधि, सभी जगह <space>एक साथ पात्रों <space>या एक oस्ट्रिंग के चरित्र सूचकांक (0 या 1) का हवाला <space>o।
  • हम चरित्र सूचकांक निर्धारित करते हैं
    1. कॉलिंग Math.random(), जो 0 और 1 के बीच एक दशमलव संख्या देता है, अनन्य।
    2. यदि इससे अधिक है तो जाँच करना .8। उनके पैनल में 40 रिक्त स्थान होने के साथ और केवल 10 होल्ड होने की अधिकतम .75संभावना है , ऐसा करने से पैनल में होल्ड के वितरण में सुधार होता है ( यह अधिक सटीक होगा, लेकिन, उम्मीद है, आप मुझे इसके लिए रियायत की अनुमति देंगे एक बाइट की बचत!)।
    3. उस चेक का बूलियन वेरिएबल को सौंपा गया है s।
    4. sएक पूर्णांक (0 या 1) के लिए बाध्य है और इसमें जोड़ा गया है h।
    5. हम जांचते हैं कि hक्या अब 11 से कम है (यानी, क्या वर्तमान में हमारे पास 10 से कम है) और अगर sयह सच था।
    6. यह बूलियन बारी-बारी से एक पूर्णांक के साथ होता है, जो हमें स्ट्रिंग में एक इंडेक्स देता है।
• वापस हमारे उत्पादन के लिए! हम द्वारा दिए गए स्ट्रिंग को दोहराते हैंg 5 बार ।
• और फिर Mexicoचीजों को समाप्त करने के लिए बस स्ट्रिंग के अंत में जोड़ें । ओह!

---

विकल्प

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

(g=(p=`|          |
`.repeat(4)+t,h=0)=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s]),h))=>`  America!
${t=`+----------+
`}${g()+g()+g()+g()+g()}    Mexico`

---

कोशिश करो

फिर से, होल्ड के पैटर्न हर 2 सेकंड में बदल जाएंगे।

f=
(g=(p=`|          |
`.repeat(4)+t,h=0)=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s]),h))=>`  America!
${t=`+----------+
`}${g()+g()+g()+g()+g()}    Mexico`
o.innerText=f()
setInterval("o.innerText=f()",2e3)

<pre id=o>

Answer 4

पायथ - 58 57 बाइट्स, संभवतः 47

Ks(b\+*\-T\+*+++b\|*dT\|4)J<.SxdmdK+3O8+*s.e?/Jk\obK5<K13

कोशिश करो

पुराने समाधान की व्याख्या (जब मेरे पास समय होगा तो मैं अपडेट करूंगा):

J+++b\+*\-T\+K+J*+++b\|*dT\|4=Y<.SxdmdK+3O8+*s.e?/Yk\obK5J
J+++b\+*\-T\+                                                Create the +----------+, and store as J
             K+J*+++b\|*dT\|4                                Create a full panel (minus bottom border, and without holes), store as K
                                  xdmdK                      Get indices of spaces
                                .S                           Create random permutation of these indices
                               <       +3O8                  Get first several indices (a random number from 3 to 10)
                                             s.e?/Yk\obK     Replace space with 'o' at these indices
                                           +*           5J   Create 5 copies, and add bottom border

मुझे लगता है कि तकनीकी नियमों का पालन करते हुए मुझे 47 मिल सकते हैं:

JhO2Ks(b\+*\-T\+*+++b\|.S+*\oJ*d-TJ\|4)+*K5<K13

यहाँ, छेद की संख्या अभी भी बेतरतीब ढंग से चुनी जाती है (सेट {4,8}) से और उन छेदों के विन्यास को बेतरतीब ढंग से चुना जाता है (कॉन्फ़िगरेशन के सेट से जहां प्रत्येक पंक्ति समान है)

कोशिश करो

Answer 5

मैथेमेटिका, 201 बाइट्स

c=Column;s=RandomSample[Tuples[{" ",o," "," "},10],4];t="+----------+";w=c[{t,c[Row/@Table[AppendTo[s[[i]],"|"];PrependTo[s[[i]],"|"],{i,Length@s}]]}];c[Flatten@{"  America!",Table[w,5],t,"   Mexico"}]

Comments

मैं जिस भाषा का परीक्षण नहीं कर सकता, उसका उपयोग करने के लिए +1?

— 17:30 22 पर caird coinheringaahing

@ Satan'sSon, आप सबसे मेथेमेटिका कार्यक्रमों मुक्त करने के लिए चला सकते हैं यहाँ Wolfram सैंडबॉक्स में। (इसे पेस्ट करें और शिफ्ट-एंटर दबाएं।)

— पेड़ नहीं

जब मुद्रण की बात आती है, तो यह साइट मजाकिया तरीके से छापती है। आउटपुट विकृत है क्योंकि यह विशेष चरखे का उपयोग करता है ...

— J42161217

Answer 6

पॉवर्सशेल (255 बाइट्स)

echo "  America!"
for($l=0;$l-lt4;$l++){$a=," "*12;$a[0]="|";$a[11]="|";$i=get-random -Max 10 -Min 6;$j=get-random -Max 5 -Min 1;$a[$i]=$a[$j]="o";$b+=($a-join"")}
for($k=0;$k-lt5;$k++){echo +----------+($b-join"`n")} 
echo +----------+`n"   Mexico" 

Answer 7

पायथन 2 , 259 224 221 218 बाइट्स

from random import*
b=[' ']*40
for x in sample(range(40),randint(3,10)):b[x]='o'
a=["+"+"-"*10+"+"]+['|'+''.join(o)+'|'for o in[b[x*10:x*10+10]for x in 0,1,2,3]] 
print'\n'.join(['  America!']+a*5+[a[0]]+['   Mexico'])

इसे repl.it पर आज़माएँ

@ शैतान के कुछ संकेत सहित -35 संकेत - धन्यवाद!

-3 के साथ @Wondercricket धन्यवाद

Comments

आप बस outputting द्वारा बाइट्स बचा सकता है tएक चर करने के बजाय यह बचाने और यदि आप के बाद रिक्त स्थान को हटा दें America!और Mexico? print" America!" <NEWLINE> d,a,b,c=[" Mexico"],["+"+"-"*10+"+"],[" "]*40,0?

— १

धन्यवाद @ शैतान का। यह एक "लंचब्रेक स्पेशल" था और जब मुझे समय मिलता है तो मैं इसे थोड़ा और अधिक गोल्फ कर सकता हूं। संकेत के लिए फिर से धन्यवाद।

— एलपेड्रो

आप अपने आयात को बदलकर from random import*और r.कार्यों से हटाने के लिए कुछ बाइट्स भी बचा सकते हैं

— Wondercricket

धन्यवाद @Wondercricket मुझे यकीन नहीं है कि मैं उस एक को कैसे याद करने में कामयाब रहा :)

— एलपेड्रो

शैतान मददगार था! (सब कुछ के लिए पहली और आखिरी बार> :(

— caird coinheringaahing

Answer 8

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

from random import*
n=randint(3,10)
s=list('o'*n+' '*(40-n))
shuffle(s)
t=10
S='+'+'-'*t+'+'
print'\n'.join(['  America!']+([S]+['|'+''.join(s[x:x+t])+'|'for x in range(0,40,t)])*5+[S,'   Mexico'])