ASCII कला एच के पेड़

Question

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

प्रथम स्तर बस तीन हाइफ़न-माइनस वर्ण हैं:

---

अगले स्तरों का पुनरावर्ती निर्माण किया जाता है:

• तीन स्तरों या रेखाओं द्वारा अलग किए गए पिछले स्तर से प्रतियों का 2x2 मैट्रिक्स बनाएं।
• एच के रूप में ASCII कला लाइनों के साथ प्रतियों के केंद्रों को कनेक्ट करें। -क्षैतिज रेखाओं के लिए उपयोग करें , |ऊर्ध्वाधर लाइनों के लिए, और +जब भी लाइनें एक दूसरे से मिलती हैं।

दूसरा स्तर

-+-   -+-
 |     |
 +-----+
 |     |
-+-   -+-

तीसरे स्तर

-+-   -+-   -+-   -+-
 |     |     |     |
 +--+--+     +--+--+
 |  |  |     |  |  |
-+- | -+-   -+- | -+-
    |           |
    +-----------+
    |           |
-+- | -+-   -+- | -+-
 |  |  |     |  |  |
 +--+--+     +--+--+
 |     |     |     |
-+-   -+-   -+-   -+-

नियम

• इनपुट एक पूर्णांक के रूप में ऊपर (वर्णित ASCII आर्ट एच पेड़ के स्तर का प्रतिनिधित्व करता है नहीं वास्तविक एच पेड़ स्तर), या तो शून्य या एक अनुक्रमित।
• आउटपुट लचीला है। उदाहरण के लिए, आप परिणाम को प्रिंट कर सकते हैं या एक नई लाइन-अलग स्ट्रिंग, प्रत्येक पंक्ति के लिए तार की एक सूची या वर्णों की 2 डी सरणी वापस कर सकते हैं।
• आप का उपयोग करना चाहिए -, |, +और अंतरिक्ष अक्षर।
• ट्रेलिंग स्पेस और तीन ट्रेलिंग व्हाइट-स्पेस लाइनों तक की अनुमति है।

यह कोड गोल्फ है। बाइट्स जीत में सबसे छोटा जवाब।

Comments

संबंधित: छोटे "एच" से एक "एच" बनाएं

— nwellnhof

Answer 1

कैनवस , 20 19 बाइट्स

ø⁸«╵［↷Ｌ⇵；ｌ⇵└┌├-×╋‼│

यहाँ कोशिश करो!

स्पष्टीकरण:

ø                    push an empty canvas
 ⁸«╵[              repeat input*2 + 1 times
     ↷               rotate clockwise
      L⇵             ceil(width/2)
        ;l⇵          ceil(height/2); leaves stack as [ ⌈½w⌉, canvas, ⌈½h⌉ ]
           └┌        reorder stack to [ canvas, ⌈½w⌉, ⌈½h⌉, ⌈½w⌉ ]
             ├       add 2 to the top ⌈w÷2⌉
              -×     "-" * (2 + ⌈w÷2⌉)
                ╋    in the canvas, at (⌈w÷2⌉; ⌈h÷2⌉) insert the dashes
                 ‼   normalize the canvas (the 0th iteration inserts at (0; 0) breaking things)
                  │  and palindromize horizontally

Answer 2

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

Ｐ-²ＦＮＦ²«⟲Ｔ²+×⁺²κＸ²ι←‖Ｏ

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

Ｐ-²

-कर्सर को बीच में छोड़ते हुए शुरुआती तीन एस प्रिंट करें ।

ＦＮ

दिए गए समय की संख्या के लिए दोहराएं।

Ｆ²«

प्रत्येक के लिए दो बार दोहराएं H। प्रत्येक लूप Hपिछले लूप से थोड़ा बड़ा होता है, लेकिन हम केवल वैकल्पिक Hएस चाहते हैं ।

⟲Ｔ²

आकृति घुमाएँ।

+×⁺²κＸ²ι←

अगली पंक्ति का आधा भाग ड्रा करें।

‖Ｏ

चरण को पूरा करने के लिए प्रतिबिंबित करें।

प्रत्येक पुनरावृत्ति पर परिणाम निम्नानुसार है:

---

|   |
+---+
|   |

-+-   -+-
 |     | 
 +-----+ 
 |     | 
-+-   -+-

|   |   |   |
+-+-+   +-+-+
| | |   | | |
  |       |  
  +-------+  
  |       |  
| | |   | | |
+-+-+   +-+-+
|   |   |   |

-+-   -+-   -+-   -+-
 |     |     |     | 
 +--+--+     +--+--+ 
 |  |  |     |  |  | 
-+- | -+-   -+- | -+-
    |           |    
    +-----------+    
    |           |    
-+- | -+-   -+- | -+-
 |  |  |     |  |  | 
 +--+--+     +--+--+ 
 |     |     |     | 
-+-   -+-   -+-   -+-

Comments

यदि आप आश्चर्य करते हैं कि 5-वें स्तर Hकैसा दिखता है, तो एक त्वरित ज़ूम-आउट नज़र: i.imgur.com/EGapcrS.png

— पॉल

Answer 3

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

L=len
def f(n):
 if n==1:return[['-']*3]
 m=[l+[' ']*3+l for l in f(n-1)];w=L(m[0]);y=L(m)/2;x=w/4-1;m=map(list,m+[' '*w,' '*x+'-'*(w-x-x)+' '*x,' '*w]+m)
 for i in range(y,L(m)-y):m[i][x]=m[i][w+~x]='|+'[m[i][x]>' ']
 return m

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

Answer 4

पर्ल 6 , 118 बाइट्स

{map ->\y{map {' |-+'.comb[:2[map {$^b%%1*$b&&6>=$^a/($b+&-$b)%8>=2},$^x/¾,y/2,y,$x/3-$_]]},2..^$_*6},2..^$_*4}o*R**2

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

0 अनुक्रमित। वर्णों का 2D सरणी देता है। मूल विचार यह है कि अभिव्यक्ति

b = y & -y   // Isolate lowest one bit
b <= x % (4*b) <= 3*b

पैटर्न उत्पन्न करता है

--- --- --- ---
 -----   ----- 
--- --- --- ---
   ---------   
--- --- --- ---
 -----   ----- 
--- --- --- ---

व्याख्या

{ ... }o*R**2  # Feed $_=2**$n into block
map ->\y{ ... },2..^$_*4  # Map y=2..2**n*4-1
map { ... },2..^$_*6      # Map $x=2..2**n*6-1
' |-+'.comb[:2[ ... ]]    # Choose char depending on base-2 number from two Bools
map { ... }  # Map coordinates to Bool
  # Horizontal lines
  ,$^x/¾  # Modulo 8*¾=6
  ,y/2    # Skip every second row
  # Vertical lines
  ,y      # Modulo 8
  ,$x/3   # Skip every third column
   -$_    # Empty middle column
# Map using expression
$^b%%1*$b&&  # Return 0 if $b is zero or has fractional part
6>=$^a/($b+&-$b)%8>=2  # Pattern with modulo 8