कैसिटिटम का आकार

Question

परिचय

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

अपने काम के लिए ASCII दुनिया में saguaro लाना है। हालाँकि, - जैसा कि वास्तविक दुनिया में - कोई भी सगुआरो दूसरे की तरह नहीं है, इसलिए आपके प्रोग्राम को अलग-अलग बांह विन्यास के साथ सगुरोस उत्पन्न करने में सक्षम होना चाहिए।

एक उदाहरण saguaro

• इनपुट: [0b10, 0b11]( [2, 3]दशमलव में, इनपुट लंबाई 2)

     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    

विशेष विवरण

एक सगुआरो में हमेशा एक आधार और एक शीर्ष होता है, जिसके बीच में स्टेम की चर मात्रा होती है। स्टेम भागों में कोई हथियार नहीं हो सकता, दाहिनी ओर एक हाथ, बाईं तरफ एक या दो हथियार हो सकते हैं।

सगुआरो वृद्धि पैटर्न को दो-बिट मान वाले इनपुट सूची के रूप में दिया जाता है। 00कोई हथियार नहीं, 01दाईं ओर 10एक हाथ, बाईं तरफ एक हाथ और 11दो हथियार (सभी बाइनरी में)। इनपुट सूची की लंबाई सागारू की ऊंचाई निर्धारित करती है।

सगुरो खंड निम्नलिखित की तरह दिखते हैं। कैक्टस भागों को #स्पष्टता के लिए ऑक्टोथोरैप्स से घिरा हुआ है, जिसे मुद्रित नहीं किया जाएगा।
एक saguaro की ऊँचाई हमेशा 4+6*knonnegative पूर्णांक के लिए वर्णों के बराबर होती है k।

#############
#     _     # Saguaro top
#    / \    #
#############
# _  | |  _ # Stem, both arms
#/ \ | | / \# Stem id: 11
#| | | | | |#
#\ \_| |_/ /#
# \__   __/ #
#    \ /    #
#############
# _  | |    # Stem, left arm
#/ \ | |    # Stem id: 10
#| | | |    #
#\ \_| |    #
# \__  |    #
#    \ |    #
#############
#    | |  _ # Stem, right arm
#    | | / \# Stem id: 01
#    | | | |#
#    | |_/ /#
#    |  __/ #
#    | /    #
#############
#    | |    # Stem, no arms
#    | |    # Stem id: 00
#    | |    #
#    | |    #
#    | |    #
#    | |    #
#############
#    | |    # Saguaro base
#    | |    #
#############

इनपुट

जैसा कि पहले कहा गया था, इनपुट में दो-बिट मानों की एक सूची होती है ( 0, 1, 2, 3दशमलव में)। यह किसी भी उचित प्रारूप में दिया जा सकता है। सूची का पहला तत्व saguaro के उच्चतम स्टेम भाग से मेल खाता है, दूसरा तत्व इसके दूसरे उच्चतम स्टेम भाग आदि से संबंधित है।
यदि आप चाहें, तो आपको अतिरिक्त इनपुट के रूप में इनपुट सूची की लंबाई की आवश्यकता हो सकती है। यदि आप ऐसा करते हैं तो कृपया इसे अपने उत्तर में निर्दिष्ट करें।

उत्पादन

आपके आउटपुट ASCII saguaro को ऊपर वर्णित के अनुसार सटीक स्टेम भागों का उपयोग करके बनाया जाना चाहिए। एक लाइन पर अनुगामी रिक्त स्थान और नई लाइनों को अनुगामी करना अनदेखा किया जाता है; आप अधिक, कम या अधिक के रूप में ऊपर निर्दिष्ट के रूप में मुद्रित कर सकते हैं।

नियम

• मानक खामियां लागू होती हैं
• यह कोड-गोल्फ होने के नाते , एक प्रोग्राम का बाइट काउंट न्यूनतम होना चाहिए

परीक्षण के मामलों

• एक बहिरंग। इनपुट:[0b01, 0b00, 0b01, 0b11]

     _     
    / \    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    

---

• बारी-बारी से हथियार। इनपुट:[0b10, 0b01, 0b10]

     _     
    / \    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |  _ 
    | | / \
    | | | |
    | |_/ /
    |  __/ 
    | /    
 _  | |    
/ \ | |    
| | | |    
\ \_| |    
 \__  |    
    \ |    
    | |    
    | |    

---

• बाहों की एक बहुतायत। इनपुट:[0b11, 0b11]

     _     
    / \    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
 _  | |  _ 
/ \ | | / \
| | | | | |
\ \_| |_/ /
 \__   __/ 
    \ /    
    | |    
    | |    

---

• कोई हथियार नहीं, जिसे भाले के रूप में भी जाना जाता है। इनपुट:[0b00]

     _     
    / \    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    
    | |    

---

• कोई शरीर नहीं, कुछ इसे एक युवा कैक्टस कहते हैं। इनपुट:[]

     _     
    / \    
    | |    
    | |    

---

Comments

क्या मैं इनपुट को भागों की मात्रा के रूप में ले सकता हूं और फिर प्रत्येक भागों की संख्या अलग-अलग है? (उदा। प्रथम परीक्षण-प्रकरण होगा 4 1 0 1 3)

— द्वीमा

क्या हम अनुगामी स्थानों को अनदेखा कर सकते हैं?

— ब्रायन एच।

@ दज़िमा आप कर सकते हैं।

— जोनाथन फ्रैच

@BrianH। हाँ; अनुगामी रिक्त स्थान हर पंक्ति पर ध्यान नहीं दिया जाता है।

— जोनाथन फ्रीच

Answer 1

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

↘_\¶/Ｆ²«Ｊ¹¦²Ｆθ¿﹪÷Ｉκ⁺¹ι²”{➙∧⊟≕δaL7ＹF¬⊕ρ↥↖_K”↓⁶↓²‖Ｔ

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

↘_\¶/

शीर्ष ड्रा करें।

Ｆ²«

हर तरफ लूप।

Ｊ¹¦²

शीर्ष के दाईं ओर नीचे की ओर कूदें।

Ｆθ

प्रत्येक तने के भाग पर लूप।

¿﹪÷Ｉκ⁺¹ι²

टेस्ट करें कि क्या एक हाथ है।

”{➙∧⊟≕δaL7ＹF¬⊕ρ↥↖_K”

यदि ऐसा है तो एक हाथ प्रिंट करें।

↓⁶

अन्यथा केवल एक ऊर्ध्वाधर रेखा प्रिंट करें।

↓²

स्टेम को प्रिंट करने के बाद, आधार प्रिंट करें।

‖Ｔ

दूसरी तरफ खींचने के लिए तैयार परावर्तित करें। एक बार जब दोनों पक्ष खींचे जाते हैं, तो पक्ष फिर से अपनी अंतिम स्थिति में वापस आ जाते हैं।

Answer 2

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

मैं एक बेहतर तरीके से महसूस करने से पहले एक और समाधान पर बहुत लंबा समय बिताता था, जो मुझे उतना समय नहीं छोड़ता था जितना मुझे इस पर काम करना पसंद था।

a=>`     _
    / \\`+a.map(([x,y])=>`
 1  | |  2
3 5 | | 4 6
7 7 | | 8 8
5 51| |24 4
 511${`| `[x]} ${`| `[y]}224
    ${`|\\`[x]} `.replace(/\d/g,m=>` _/\\|`[m%2?x*-~m/2:y*m/2])+`|/`[y],s=`
    | |`).join``+s+s

---

कोशिश करो

o.innerText=(f=
a=>`     _
    / \\`+a.map(([x,y])=>`
 1  | |  2
3 5 | | 4 6
7 7 | | 8 8
5 51| |24 4
 511${"| "[x]} ${"| "[y]}224
    ${"|\\"[x]} `.replace(/\d/g,m=>` _/\\|`[m%2?x*-~m/2:y*m/2])+"|/"[y],s=`
    | |`).join``+s+s
)(i.value=["11","10","01","00"]);oninput=_=>o.innerText=f(i.value.split`,`)

<input id=i><pre id=o>

Comments

00,01,10,11बाइनरी इनपुट या के बजाय, इनपुट के रूप में शाब्दिक लेने में 0,1,2,3। ओपी परीक्षण मामलों का उपयोग करना यह विफल रहता है।

— ब्रायन एच।

@BrianH: इनपुट पर चुनौती की युक्ति का हवाला देते हुए: " यह किसी भी उचित प्रारूप में दिया जा सकता है "

— झबरा

लेकिन यह बताता है कि "इनपुट में दो-बिट मानों (0, 1, 2, 3 दशमलव में) की एक सूची शामिल है।" उससे ठीक पहले ... (btw im downvoting या anythin नहीं, यह पागलपन की बात है, यह सिर्फ नियमों की मेरी व्याख्या है कि इनपुट मेल नहीं खाता)

— ब्रायन एच।

Answer 3

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

lambda l:'     _\n    / \\\n'+'\n'.join(('    |',' /|\  _   \  \|\_    __ |||| \\'[j::6])[i/2]+' '+('|','|||| /   __  /|/_ _   /  \|/'[j::6])[i%2]for i in l for j in range(6))+'\n    | |'*2

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

Answer 4

पायथन 2 , 256 253 ... 205 203 199 बाइट्स

r=[('     _',''),('/','\ ')]
for a in input()+[0]:r+=zip(*[['|'*6,'_|    |_,,/|  \/  |\,,||  ||  ||,,\| _\/_ |/,,\ ____ /,,\/'[i::2].split(',')][2-i&a>0]for i in 0,1])
for l in r[:-4]:print'%5s %s'%l

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

Comments

जैसा कि आप अन्य स्ट्रिंग शाब्दिक में करते हैं, पहली पंक्ति में आप बचने वाले बैकस्लैश को छोड़ सकते हैं।

— जोनाथन फ्रीच

ऐसा लगता है कि आप सभी अनुगामी स्थानों को हटाकर 18 बाइट्स बचा सकते हैं।

— झबरा

for ...:\n r...\n r...-> for ...:r...;r...तीन बाइट्स बचाता है।

— जोनाथन फ्रेच

Answer 5

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

param($a)'     _
    / \'
($a|%{((,'1|'*6),('1|  _
1| / \
1|2
1|_/ /
1 __/ 
1/'),(' _ 2
/ \2
| |2
\ \_| |
 \__  |
    \ |'),(' _ 2  _
/ \2 / \
| |22
\ \_| |_/ /
 \__   __/
    \ /'))[$_]})-replace1,'    | '-replace2,' | |'
,'    | |'*2

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

PowerShell में a नहीं है map या zipदोहराया वर्गों के सरल प्रतिस्थापन - तो हम कुछ और के साथ छोड़ दिया हो, तार उल्टा करने के लिए या एक असली आसान तरीका है।

पहली दो लाइनें पूर्णांक के एक सरणी के रूप में इनपुट लेती हैं और कैक्टस के शीर्ष पर आउटपुट करती हैं। फिर हम लूप करते हैं $aऔर वर्तमान मूल्य के आधार पर चार स्ट्रिंग्स की एक सरणी में चयन करते हैं। उन तारों को पाइप लाइन पर छोड़ दिया जाता है और फिर हम -replaceउपयुक्त स्थानों को भरने के लिए उपयोग करते हैं। फिर हमने पाइपलाइन पर कैक्टस के निचले हिस्से को भी डाल दिया।

सब कुछ पाइपलाइन से इकट्ठा किया जाता है और Write-Outputप्रत्येक तत्व के बीच एक नई रेखा सम्मिलित करते हुए, कार्यक्रम पूरा होने पर एक निहित होता है।

Answer 6

05AB1E , 76 75 बाइट्स

„ _…/ \‚4ú»,v6F'|4ú"_ |/\"•Aö¡Èèj{^ë•5вèJ5ôNè©‚y1›èð'|®∞2äθ‚yÉèJ,}}„| 4úû=,

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

Comments

मेह, इया हां को हराने की कोशिश करते हैं, हालांकि इस पर संदेह है।

— मैजिक ऑक्टोपस उर्फ़

@MagicOctopusUrn: शुभकामनाएँ! आशा है कि आप इसे प्रबंधित करेंगे (और शायद इसे झड़प में बदल सकते हैं: P)

— एमिग्ना

इसे हरा देने का मेरा एक अच्छा विचार "oasis / 05AB1E" चैट में पोस्ट की गई कमांड के 30 बाइट्स b / c की तरह स्क्वैश था। अच्छा गोल्फ, अगर मैंने कोशिश की तो यह अभी बहुत करीब होगा।

— मैजिक ऑक्टोपस Urn

Answer 7

जावा (ओपनजेडके 8) , 626 566 499 466 398 312 310 308 बाइट्स

एक टन का गोल्फ हो सकता है

a->{String r=" |,",g="    |",n="     _,    / \\,";boolean j,k;for(int e:a)n+=((k=e>1)?" _  |":g)+((j=e%2>0)?" |  _,":r)+(k?"/ \\ |":g)+(j?" | / \\,":r)+(k?"| | |":g)+(j?" | | |,":r)+(k?"\\ \\_|":g)+(j?" |_/ /,":r)+(k?" \\__ ":g)+(j?"  __/,":r)+(k?"    \\":g)+(j?" /,":r);return(n+g+r+g+r).replace(",","\n");}

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

Comments

आप बदल {j=e>1;k=e%2>0;n+=(k?" _ |":g)+(j?" | _,":r)+सकते हैं n+=((k=e%2>0)?" _ |":g)+((j=e>1)?" | _,":r)+और }साथ ही लूप के समापन को हटाकर 2 बाइट्स बचा सकते हैं ।

— केविन क्रूज़सेन

आप "शाखा" के लिए गलत तरीके से 'दौर है 1और 2।

— झबरा

Answer 8

SOGL V0.12 , 56 54 53 बाइट्स

5⁷yΙ‚‘∑≡`a#¾‘O.{@.2%i»¹{"⁸G‘6∙;?X"j1>ζ╔²i[n¹‘5n}┼±↔}O

यह कोशिश करो!

स्पष्टीकरण:

..‘                   push the ending part - "    | |\n    | |"
   ..‘O               output the starting part - "     _ \n    / \"
       .{             input times do
         @              push a space
          .2%           push input%2
             i»         push floor(prevInput/2)
               ¹        wrap the two in an array

{                   }   for each of the two numbers
 "..‘                     push "|    " - base stem
     6∙                   multiply vertically 6 times
       ;?       }         if the current item iterating over is truthy (i.e. != 0)
         X                  remove ToS - the regular stem - from the stack 
          "..‘              push "|  _ | / \| | ||_/ / __/ /    " - stem with an arm
              5n            split it into line lengths of 5
                 ┼        add that horizontally to the space pushed earlier (or whatever it's become)
                  ±↔      reverse ToS - the stem currently - horizontally
                     O  output the array of the current part