बाइनरी ट्री फ्रैक्टल

Question

आज की चुनौती इस उदाहरण की तरह एक बाइनरी ट्री को सुंदर आस्की-कला के रूप में आकर्षित करना है :

                               /\
                              /  \
                             /    \
                            /      \
                           /        \
                          /          \
                         /            \
                        /              \
                       /                \
                      /                  \
                     /                    \
                    /                      \
                   /                        \
                  /                          \
                 /                            \
                /                              \
               /\                              /\
              /  \                            /  \
             /    \                          /    \
            /      \                        /      \
           /        \                      /        \
          /          \                    /          \
         /            \                  /            \
        /              \                /              \
       /\              /\              /\              /\
      /  \            /  \            /  \            /  \
     /    \          /    \          /    \          /    \
    /      \        /      \        /      \        /      \
   /\      /\      /\      /\      /\      /\      /\      /\
  /  \    /  \    /  \    /  \    /  \    /  \    /  \    /  \
 /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

आपको इनपुट के रूप में एक सकारात्मक पूर्णांक दिया जाएगा। यह इनपुट पेड़ की ऊंचाई है । उपरोक्त उदाहरण की ऊंचाई छह है।

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

प्रत्येक पंक्ति पर अनुगामी रिक्त स्थान की अनुमति है।

यहां इनपुट्स और उनके संबंधित आउटपुट के कुछ उदाहरण दिए गए हैं:

1:
/\

2:
 /\
/\/\

3:
   /\
  /  \
 /\  /\
/\/\/\/\

4:
       /\
      /  \
     /    \
    /      \
   /\      /\
  /  \    /  \
 /\  /\  /\  /\
/\/\/\/\/\/\/\/\

5:
               /\
              /  \
             /    \
            /      \
           /        \
          /          \
         /            \
        /              \
       /\              /\
      /  \            /  \
     /    \          /    \
    /      \        /      \
   /\      /\      /\      /\
  /  \    /  \    /  \    /  \
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

दुर्भाग्य से, आउटपुट तेजी से बढ़ता है, इसलिए बड़े उदाहरण दिखाना मुश्किल है। यहाँ 8 के लिए आउटपुट का लिंक दिया गया है।

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

हैप्पी गोल्फिंग!

Comments

क्या सभी रेखाओं को समान लंबाई बनाने के लिए अनुगामी स्थान हो सकते हैं?

— xnor

@xnor हाँ, यह ठीक है।

— DJMcMayhem

Answer 1

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

S=s=i=2**input()
while s:print S/s*('/'+' '*(s-i)+'\\').center(s);i-=2;s/=s/i

रिक्त स्थान के साथ प्रिंट, त्रुटि के साथ समाप्त करना।

मैं इस कोड लिया जमा करते के लिए एक चुनौती रहा अराजकता गोल्फ पर उत्पन्न खतरे के अलावा एक एक-बाइट सुधार xsot द्वारा पाया। 128 के हार्डकोडेड मान को बदल दिया गया था 2**input()।

विचार यह है कि आउटपुट की प्रत्येक पंक्ति एक सेगमेंट को एक या अधिक बार कॉपी किया जाता है। इनपुट विभाजन के बाद के आधे हिस्से में प्रत्येक खंड की एक प्रति है, अगले विभाजन के बाद की तिमाही में दो प्रतियां हैं, और इसी तरह, कई खंडों वाली अंतिम पंक्ति तक /\।

प्रत्येक खंड एक था /और \बीच, साथ ही सही लंबाई करने के लिए पैड के लिए बाहर की दुनिया में में रिक्त स्थान के साथ,। बाहरी गद्दी के साथ किया जाता है center।

चर sप्रत्येक खंड के साथ धारा को ट्रैक करता है, और खंडों की संख्या S/sइतनी है कि कुल चौड़ाई पेड़ की चौड़ाई है S। पंक्ति संख्या i2 से नीचे गिना जाता है, और जब भी इसका मूल्य sआधा होता है, एक विभाजन होता है, और खंड की चौड़ाई आधी हो जाती है। यह अभिव्यक्ति के माध्यम से किया जाता है s/=s/i। जब iपहुंचता है 0, तो यह एक त्रुटि देता है जो प्रोग्राम को समाप्त करता है।

चूंकि एनगॉल्फ़ केवल प्रोग्राम सबमिशन की अनुमति देता है, मैंने एक पुनरावर्ती फ़ंक्शन की संभावना का पता नहीं लगाया, जो मुझे लगता है कि संभावना कम है।

Answer 2

वी , 32 बाइट्स

é\é/À­ñLyPÄlx$X>>îò^llÄlxxbPò
|

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

Hexdump:

00000000: e95c e92f c0ad f116 4c79 50c4 6c78 2458  .\./....LyP.lx$X
00000010: 3e3e eef2 5e6c 6cc4 6c78 7862 50f2 0a7c  >>..^ll.lxxbP..|

Answer 3

कैनवस , 11 बाइट्स

/║╶╷［ｌ＼；∔↔║

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

स्पष्टीकरण:

/║          push `/\` ("/" palindromized so this is a Canvas object)
  ╶╷[       repeat input-1 times
     l        get the width of the ToS
      \       create a diagonal that long
       ;∔     prepend that to the item below
         ↔    reverse the thing horizontally
          ║   and palindromize it horizontally

Answer 4

हास्केल , 140 138 135 बाइट्स

e n=[1..n]>>" "
n!f=(e n++).(++e n)<$>f
f 0=[]
f n=1!f(n-1)++['/':e(2*n-2)++"\\"]
b n|n<2=f 1|t<-b$n-1,m<-2^(n-2)=m!f m++zipWith(++)t t

इसे ऑनलाइन आज़माएं! के साथ कॉल करें b 5, स्ट्रिंग्स की सूची लौटाता है।

सुंदर प्रिंट उपयोग:

*Main> putStr . unlines $ b 5
               /\
              /  \
             /    \
            /      \
           /        \
          /          \
         /            \
        /              \
       /\              /\
      /  \            /  \
     /    \          /    \
    /      \        /      \
   /\      /\      /\      /\
  /  \    /  \    /  \    /  \
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

(कुछ) स्पष्टीकरण:

• e nnरिक्त स्थान की एक स्ट्रिंग उत्पन्न करता है
• n!fबाएँ और दाएँ रिक्त स्थान के fसाथ तार की सूची में प्रत्येक स्ट्रिंग पैडn
• f nआयत nद्वारा एक "चोटी" खींचता है2n
• b n बाइनरी ट्री को दो छोटे पेड़ों को समतल करके और उनके ऊपर एक नई चोटी को खींचता है

संपादित करें: -3 बाइट्स जर्ब के लिए धन्यवाद!

Comments

मुझे लगता है 1!f(n-1)और m!f mबाइट्स के एक जोड़े को बचाना चाहिए।

— जर्बर्ब

@Zgarb इंगित करने के लिए धन्यवाद, उन पूर्ववर्ती नियमों को कभी-कभी भ्रमित किया जाता है।

— लकोनी

Answer 5

जे , ४ ९ ४३ ४२ बाइट्स

' /\'{~(|.,-)"1@(=@i.@#,-)^:(<:`(,:@,&*-))

यह एक क्रिया का मूल्यांकन करता है जो एक संख्या लेता है और एक 2 डी चरित्र सरणी देता है। इसे ऑनलाइन आज़माएं!

व्याख्या

मैं पहले सहायक क्रिया की पुनरावृति करके मूल्यों -1, 0 और 1 के एक मैट्रिक्स का निर्माण करता हूं, और फिर वर्णों द्वारा संख्याओं को प्रतिस्थापित करता हूं। सहायक क्रिया अगले पुनरावृत्ति के दाहिने आधे हिस्से का निर्माण करती है, फिर बाकी हिस्सों का उत्पादन करने के लिए इसे क्षैतिज रूप से दर्पण करती है। निम्नलिखित स्पष्टीकरण में, ,2 डी सरणियों को लंबवत और 1D सरणियों को क्षैतिज रूप से समतल किया जाता है।

' /\'{~(|.,-)"1@(=@i.@#,-)^:(<:`(,:@,&*-))  Input is n.
                          ^:(            )  Iterate this verb
                             <:             n-1 times
                               `(       )   starting from
                                    ,&*-    the array 1 -1 (actually sign(n), sign(-n))
                                 ,:@        shaped into a 1x2 matrix:
                                             Previous iteration is y.
                      #                      Take height of y,
                   i.@                       turn into range
                 =@                          and form array of self-equality.
                                             This results in the identity
                                             matrix with same height as y.
                       ,-                    Concatenate with -y, pad with 0s.
       (    )"1@(        )                   Then do to every row:
        |.,-                                 Concatenate reversal to negation.
' /\'{~                                     Finally index entry-wise into string.

Answer 6

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

f=n=>n<2?"/\\":" "+f(n-1).split`/`[0].replace(/|/g,"$`$'$'/$`$`\\$'$'$` \n")+f(n-1).replace(/.*/g,"$&$&")

आधार मामले से पुनरावर्ती रूप से परिणाम का निर्माण करके काम करता है /\। नीचे का आधा केवल प्रत्येक पंक्ति के साथ पिछले मामले को दोहराया गया है। शीर्ष आधा थोड़ा पेचीदा था; ऐसा लगता है कि आप पिछले मामले को लेना चाहते हैं और केवल दो पक्षों को रखना चाहते हैं, लेकिन आपको स्ट्रिंग्स को चौड़ी करने के बारे में भी चिंता करनी होगी, इसलिए मैं कुछ रेगेक्स जादू करता हूं। पिछले मामले से अग्रणी स्थान लेकर और हर बिंदु पर विभाजित करके, मैं उस बिंदु से पहले और बाद में रिक्त स्थान पर विचार कर सकता हूं। प्रत्येक मैच में 1 से बढ़ने से पहले रिक्त स्थान और 1 से कमी के बाद रिक्त स्थान; इस स्थिति के लिए इस्तेमाल किया जा सकता है /और\सही स्थानों पर। यहाँ पर नए सिरे और पेडिंग को भी जोड़ा गया है; यह प्रत्येक पंक्ति पर एक अनुगामी स्थान और पहली पंक्ति पर एक अग्रणी स्थान को छोड़कर सभी पैडिंग का ध्यान रखता है जिसे मुझे मैन्युअल रूप से जोड़ना होगा। (बाद की तर्ज पर अग्रणी स्थान मिलान स्ट्रिंग से आते हैं)।

Answer 7

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

ＦＮ«→↗⌈Ｘ²⊖ι‖Ｍ

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

 Ｎ              Input as a number
Ｆ «             Loop over implicit range
   →            Move right (because mirroring moves the cursor)
         ι      Current index
        ⊖       Decremented
      Ｘ²        Power of 2
     ⌈          Ceiling
    ↗           Draw diagonal line
          ‖Ｍ    Mirror image

लाइन की लंबाई 1, 1, 2, 4, 8 ... 2 ^ (एन -2) है, इस प्रकार अजीब गणना।

Answer 8

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

≡mX░R○k╣∙╒ab^◘⌐╖x▼;

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

Answer 9

बैच, 218 बाइट्स

@echo off
set/a"n=1<<%1"
set s=set t=
%s%/\
set l=for /l %%i in (2,1,%n%)do call
%l% %s% %%t%% 
%l%:l
:l
echo %t%
set/an-=1,m=n^&n-1
%s%%t: /=/ %
%s%%t:\ = \%
if %m% neq 0 exit/b
%s%%t:/ =/\%
%s%%t: \=/\%

नोट: पंक्ति 6 ​​एक स्थान पर समाप्त होती है। शाखाओं को हर बार बाएं और दाएं उचित रूप से स्थानांतरित करके काम करता है, सिवाय उन पंक्तियों को छोड़कर , जो अंत से 2 ^एन हैं , जिस स्थिति में शाखाएं इसके बजाय कांटा हो जाती हैं।

Answer 10

हैक्स, 181 बाइट्स

function g(n):String return(n-=2)==-1?"/\\":[for(y in 0...1<<n)[for(x in 0...4<<n)x+y+1==2<<n?"/":x-y==2<<n?"\\":" "].join("")].concat([for(y in g(n+1).split("\n"))y+y]).join("\n");

या, कुछ वैकल्पिक व्हाट्सएप के साथ:

function g(n):String
  return
    (n -= 2) == -1
    ? "/\\"
    : [ for (y in 0...1 << n)
        [ for (x in 0...4 << n)
          x + y + 1 == 2 << n
          ? "/"
          : x - y == 2 << n
            ? "\\"
            : " "
        ].join("")
      ].concat([ for (y in g(n + 1).split("\n"))
        y + y
      ]).join("\n");

मैं कुछ समय के लिए एक समाधान पर काम कर रहा था, जिसने पहले सही आकार के अंतरिक्ष वर्णों की एक सरणी बनाई, फिर पुनरावृत्त ने कांटेदार रास्तों को कम और निचले हिस्से में रखा (और प्रत्येक पुनरावृत्ति पर अधिक घनत्व)। हालांकि यह 230+ बाइट्स रहा। यहाँ दृष्टिकोण काफी हद तक @ लैकोनी के हास्केल दृष्टिकोण का है। मैं नहीं होने के साथ दूर नहीं जा सका :String, क्योंकि हैक्स यह पहचानने के लिए पर्याप्त स्मार्ट नहीं है कि रिटर्न प्रकार हमेशा एक स्ट्रिंग होगा।

यह केवल एक फ़ंक्शन है, यहाँ इसका परीक्षण करने के लिए एक पूर्ण कार्यक्रम है:

class Main {
    public static function main(){
        function g(n):String return(n-=2)==-1?"/\\":[for(y in 0...1<<n)[for(x in 0...4<<n)x+y+1==2<<n?"/":x-y==2<<n?"\\":" "].join("")].concat([for(y in g(n+1).split("\n"))y+y]).join("\n");
        Sys.println(g(Std.parseInt(Sys.args()[0])));
    }
}

ऊपर रखो Main.hx, के साथ संकलन haxe -main Main.hx -neko frac.nऔर परीक्षण neko frac.n 4( 4वांछित आदेश के साथ बदलें )।

Answer 11

PHP, 188 बाइट्स

ऑनलाइन संस्करण

function f($l,$r=0,$m=1){global$a;for(;$i<$l;$i++)$i<$l/2?$a[$i+$r]=str_repeat(str_pad("/".str_pad("",2*$i)."\\",2*$l," ",2),$m):f($l/2^0,$r+$l/2,2*$m);}f(2**$argv[1]/2);echo join("\n",$a);

विस्तारित

function f($l,$r=0,$m=1){
global$a;    
for(;$i<$l;$i++)    
$i<$l/2
    ?$a[$i+$r]=str_repeat(str_pad("/".str_pad("",2*$i)."\\",2*$l," ",2),$m)
    :f($l/2^0,$r+$l/2,2*$m);
}
f(2**$argv[1]/2);
echo join("\n",$a);