18

एसओ के हालिया सवाल से प्रेरित ...

निम्नलिखित प्रारूप में एक बाइनरी ट्री प्रिंट करने के लिए एक फ़ंक्शन लिखें:

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

इनपुट:

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

आप किसी आउटपुट स्ट्रीम पर प्रिंट कर सकते हैं या आउटपुट, अपनी पसंद से युक्त स्ट्रिंग लौटा सकते हैं।

कम से कम कोड के लिए अंक, लेकिन मैं बहुत 90%-एक कम से कम एक पूरी तरह से काम कर रहे लंबे समाधान पसंद करेंगे।

इनाम के लिए अद्यतन:

इनाम के लिए, मैं (ऑप्टिमाइज़र) थोड़ा बदलाव कर रहा हूँ:

इनपुट STDIN, ARGV या फ़ंक्शन तर्क से हो सकता है।
आउटपुट STDOUT पर होना चाहिए (या console.logJS के लिए)
आप मान सकते हैं कि इनपुट पूर्व के लिए, सरणी के रूप में है। [1,2,3]या[1 2 3]

अपडेट 2 - बाइनरी ट्री वास्तव में एक बाइनरी सर्च ट्री होना चाहिए। चूंकि मैंने शुरू में इसका उल्लेख नहीं किया था, इसलिए मैं उपयोगकर्ताओं को एक सामान्य सरणी को एक अलग प्रोग्राम के रूप में बाइनरी सर्च ट्री सरणी में परिवर्तित करने की अनुमति दूंगा और अंतिम बाइट गिनती केवल प्रोग्राम के लिए तर्क के रूप में सरणी में लेने और इसे प्रिंट करने के लिए होगी। एक बाइनरी ट्री की तरह।

code-golf ascii-art binary-tree

— Anon।
स्रोत

क्या हमें कई संबंध स्लैश का उपयोग करना उचित था? क्या हमें स्लैश की न्यूनतम संख्या का उपयोग करना चाहिए? क्या एक एकल बाएं बच्चे और एक सही बच्चे के बीच अंतर करना चाहिए? क्या हर आउटपुट लाइन में अग्रणी स्थान होना ठीक रहेगा?

अगर पेड़ पूरा नहीं होता है (2 ^ n-1 नोड्स के लिए कुछ n) तो हम क्या करें? कुछ नोड्स (जो लोग?) का केवल एक बच्चा है। लेकिन अगर हमें केवल एक बच्चे के साथ नोड्स की अनुमति है, तो पतित पेड़ बनाने के लिए आसान है (1-2-3-4-5-6 नीचे और दाईं ओर, कहते हैं)।

— कीथ रान्डेल

आप इसे बड़ी संख्या के लिए कैसे आकर्षित करते हैं? उदाहरण के लिए30000,1000,499999

— मोहसिन

9

फोरट्रान 77 - 1085 अक्षर

      subroutine q(u,t)
      implicit integer(i-z)
      character*33 f,g
      dimension t(u)
      m=ceiling(log(real(u))/log(2.))
      v=2**(m+1)-1
      do l=1,m
         n=2**(l-1)
         k=2**(m-l+2)-3
         w=(3+k)*2**(l-1)-k
         p=1+(v-w)/2
         if(l.ne.1)then
            write(f,'(A,I3,A)')'(A',p,',$)'
            print f,' '
            write(f,'(A5,I3,A3)')'(A3,A',k,',$)'
            do j=2**(l-1),2**l-1
               if(t(j/2).lt.0.or.t(j).lt.0)then
                  print f,'   ',' '
               elseif(mod(j,2).eq.0)then
                  print f,'  /',' '
               else
                  print f,' \ ',' '
               endif
            enddo
            print*
         endif
         write(f,'(A,I3,A)')'(A',p,',$)'
         print f,' '
         write(f,'(A5,I3,A3)')'(I3,A',k,',$)'
         write(g,'(A2,I3,A3)')'(A',k+3,',$)'
         do j=2**(l-1),2**l-1
            if(t(j).ge.0)then
               print f,t(j),' '
            else 
               print g,' '
            endif
         enddo
         print*
      enddo
      end

पेड़ को tसामान्य रूप में इनपुट सरणी में दर्शाया गया है , 1 पर रूट, रूट-> 2 पर छोड़ा गया, रूट-> 3 रूट पर दाएं-> बाएं-> 4 पर छोड़ा ...

आउटपुट को पारंपरिक टर्मिनल में 5 स्तरों तक फिट होना चाहिए।

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

टिप्पणियों और एक लॉन्चिंग पाड़ के साथ पूरा कार्यक्रम:

      program tree

      parameter (l=8)          ! How many nodes to support
      dimension i(l)

c     Initialize the array to all empty nodes
      do j=1,l
         i(j)=-1
      end do
c     Fill in some values
      i(1)=3
      i(2)=1
      i(3)=5
      i(5)=2
      i(6)=4
      i(7)=7
c      i(14)=6
c      i(15)=8
c     Call the printing routine
      call q(l,i)

      stop
      end

c     Print an ASCII representation of the tree
c
c     u the length of the array containing the tree
c     t an integer array representing the tree.
c
c     The array contains only non-negative values, and empty nodes are
c     represented in the array with -1.
c
c     The printed representation uses three characters for every node,
c     and places the (back) slash equally between the two node-centers.
      subroutine q(u,t)
      implicit integer(i-z)
      character*33 f,g
      dimension t(u)
      m=ceiling(log(real(u))/log(2.)) ! maximum depth of the tree
      v=2**(m+1)-1              ! width needed for printing the whole tree
                                ! Optimized from 3*2**m + 1*((2**m)-1) at
                                ! the bottom level
      do l=1,m
         n=2**(l-1)             ! number of nodes on this level
         k=2**(m-l+2)-3         ! internode spacing
         w=(3+k)*2**(l-1)-k     ! width needed for printing this row
                                ! Optimized from 3*2**l + k*((2**l)-1) at
                                ! the bottom level
         p=1+(v-w)/2            ! padding for this row
c     Print the connecting lines associated with the previous level
         if(l.ne.1)then         ! Write the connecting lines
            write(f,'(A,I3,A)')'(A',p,',$)'
            print f,' '
            write(f,'(A5,I3,A3)')'(A3,A',k,',$)'
            do j=2**(l-1),2**l-1
               if(t(j/2).lt.0.or.t(j).lt.0)then
                  print f,'   ',' '
               elseif(mod(j,2).eq.0)then
                  print f,'  /',' '
               else
                  print f,' \ ',' '
               endif
            enddo
            print*
         endif
c     Print the nodes on this level
         write(f,'(A,I3,A)')'(A',p,',$)'
         print f,' '
         write(f,'(A5,I3,A3)')'(I3,A',k,',$)'
         write(g,'(A2,I3,A3)')'(A',k+3,',$)'
         do j=2**(l-1),2**l-1
            if(t(j).ge.0)then
               print f,t(j),' '
            else 
               print g,' '
            endif
         enddo
         print*
      enddo
      end

उदाहरण के समकक्ष इनपुट के साथ आउटपुट:

— dmckee
स्रोत

मदद क्यों इस भाषा?

— शाम

9

क्योंकि यह गोल्फिंग के लिए बहुत खराब है।

— dmckee

5

CJam, 100 99 बाइट्स

q~_,2b,)2\#:Q1@{_2$<Q(S*:T*TQ2/:Q@ts[N+_0@{@1$' >{2$St2$_Q3*&2/^_4$>"\/"=t}*@)}/;U*o]o1:U$>\2*\}h];

इनपुट में पात्रों की एक सूची होनी चाहिए, बिना किसी एएससीआई नियंत्रण वर्णों की। खाली नोड्स को एक स्थान द्वारा निरूपित किया जाता है। यह भी बिल्कुल सही बाइनरी ट्री होना चाहिए जिसमें 2 ^एन -1 नोड्स हों।

उदाहरण:

['6 '3 '7 '1 '4 '  '9 '0 '2 '  '5 '  '  '8 ' ]

या बस तार का उपयोग करें:

"63714 902 5  8 "

आउटपुट:

                6              
            /       \          
        3               7      
      /   \               \    
    1       4               9  
   / \       \             /   
  0   2       5           8

व्याख्या

q~                        " Read input. ";
_,2b,                     " Get tree height. ";
)2\#:Q                    " Get (displayed) tree width and save it in Q. ";
1@                        " Push X=1 and rotate the input to top. ";
{                         " Do: ";
    _2$<                  " Get first X characters from the input. ";
    Q(S*:T                " T = (Q-1) spaces. ";
    *                     " Separate the X characters by T. ";
    TQ2/:Q@t              " Put the string in the middle of T, and divide Q by 2. ";
    s                     " Concatenate everything into a string.
                            This is the line of node labels. ";
    [
        N+                " Append a newline. ";
        _                 " Duplicate. ";
        0@                " Push a 0 and rotate the original string to top. ";
        {                 " For each character: ";
            @             " Rotate the duplicate to top. ";
            1$' >         " Test if the current character is greater than a space. ";
            {             " If true: ";
                2$St      " Set the current character in the duplicate to space. ";
                2$        " Copy the current position I (the number initialized with 0). ";
                _Q3*&2/^  " Calculate I ^ ((I & (3*Q))>>1),
                            the position of the relationship character. ";
                _4$>      " Test if it is greater than the current position. ";
                "\/"=     " Select the relationship character. ";
                t         " Change the character in the duplicate. ";
            }*
            @)            " Increment the current position. ";
        }/
                          " The last two items are the line of relationship characters
                            and the tree width. ";
        ;                 " Discard the tree width. ";
        U*                " If it is the first line, empty the line of
                            relationship characters. ";
        o                 " Output. ";
    ]o                    " Output the line of node labels. ";
    1:U                   " Mark it not the first line. ";
    $>                    " Remove the first X characters from the input. ";
    \2*\                  " Multiply X by 2. ";
}h                        " ...while the input is not empty. ";
];                        " Discard everything in the stack. ";

रूपांतरण स्क्रिप्ट

[[0LL]W]
[q~{_a_:i={'0+}*}%La2*f+
_,,]z$
1$a+
{
    {
        1$1=1$1=>:T
        {
            ~@0=2 3$1=t
            @1@ta\+
        }*
        T
    }g
}*
0=1=a
{
    {
        (M\+:M;
        La[' LL]aer~
    }%
    _[' LL]a-
}g
];
M0+`-3<']+

यह वर्ण या एकल अंकों की संख्या को स्वीकार करता है।

उदाहरण (सभी समान हैं):

['6 '7 '9 '3 '1 '2 '8 '4 '0 '5]
[6 7 9 3 1 2 8 4 0 5]
"6793128405"

आउटपुट:

['6 '3 '7 '1 '4 ' '9 '0 '2 ' '5 ' ' '8 ' ]

यह एक सीधे-अग्रवर्ती कार्टेशियन वृक्ष निर्माण है।

— jimmy23013
स्रोत

आप केवल दो और बाइट्स जोड़ सकते हैं और रूपांतरण स्क्रिप्ट के इनपुट को वर्णों के बजाय उचित पूर्णांक के रूप में बना सकते हैं :)

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र ने दोनों को सपोर्ट करने के लिए एडिट किया। मुझे लगता है कि वर्ण अधिक मायने रखता है क्योंकि यह केवल एकल वर्ण के साथ नोड नामों का समर्थन करता है। एकल अंकों की संख्या की तुलना में बहुत अधिक वर्ण हैं।

— jimmy23013

2

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

import math
def g(a,o,d,l,b):
 if l<0:
    return
 c=2*b+1
 k=2*l+1
 o[k]=' '*b
 n=d-l
 p=1 if n==0 else 3*2**n-1
 o[k-1]=p/2*' '
 i=0
 for v in a[2**l-1:2**l*2-1]:
    v=' ' if v==None else v
    o[k]+=v+' '*c
    m=' ' if v==' ' else '/' if i%2==0 else '\\'
    o[k-1]+=m+max(1,b)*' ' if i%2==0 else m+p*' '
    i+=1

 g(a,o,d,l-1,c)
def f(a):
 d=int(math.log(len(a),2))
 o=['']*(d*2+2)
 g(a,o,d,d,0)
 print '\n'.join(o[1:])

नोट: पहला इंडेंटेशन स्तर 1 स्थान है, दूसरा एक टैब है।

fएक-वर्ण स्ट्रिंग्स या Noneउदाहरण के लिए, की सूची के साथ कॉल करें । f(['1',None,'3'])। सूची खाली नहीं हो सकती।

यह इनाम के लिए नियमों का पालन करना चाहिए।

कनवर्टर स्क्रिप्ट:

बाइनरी ट्री प्रिंटर द्वारा उपयोग किए गए प्रारूप में कनवर्ट करता है और सरणी। उदाहरण:

$ python conv.py [3,5,4,6,1,2]
['3', '1', '5', None, '2', '4', '6']

-

import sys

def insert(bt, i):
    if i < bt[0]:
        j = 0
    else:
        j = 1

    n = bt[1][j]
    if n == [None]:
        bt[1][j] = [i, [[None], [None]]]
    else:
        insert(bt[1][j], i)

def insert_empty(bt, i):
    if i == 0:
        return
    if bt == [None]:
        bt += [[[None], [None]]]

    insert_empty(bt[1][0], i - 1)
    insert_empty(bt[1][1], i - 1)

def get(l, level):
    if level == 0:
        if type(l) == list:
            return ([], l)
        else:
            return ([l], [])
    elif type(l) != list:
        return ([], [])

    res = []
    left = []

    for r, l in  [get(i, level - 1) for i in l]:
        res += r
        left += l

    return (res, left)

if __name__ == '__main__':
    l = eval(sys.argv[1])
    bt = [l[0], [[None], [None]]]
    map(lambda x: insert(bt, x), l[1:])

    depth = lambda l: 0 if type(l) != list else max(map(depth, l)) + 1
    d = (depth(bt) + 1) / 2

    insert_empty(bt, d - 1)

    flat = []
    left = bt
    i = 0
    while len(left) > 0:
        f, left = get(left, 1)
        flat += f

        i += 1

    for i in range(len(flat) - 1, -1, -1):
        if flat[i] == None:
            flat.pop()
        else:
            break

    flat = map(lambda x: None if x == None else str(x), flat)

    print flat

उदाहरण:

इन्हें चलाने के लिए आपके पास मुख्य फ़ाइल नाम bt.pyऔर कनवर्टर फ़ाइल नाम होना चाहिए conv.py।

$ python conv.py [3,5,4,6,1,2] | python -c 'import bt; bt.f(input())'
   3
  / \
 1   5
  \ / \
  2 4 6
$ python conv.py [5,4,3,7,9] | python -c 'import bt; bt.f(input())'
   5
  / \
 4   7
/     \
3     9
$ python conv.py [1,2,3,4,5,6] | python -c 'import bt; bt.f(input())'
                               1
                                       \
                                               2
                                                   \
                                                       3
                                                         \
                                                           4
                                                            \
                                                             5
                                                              \
                                                              6
$ python conv.py [6,5,4,3,2,1] | python -c 'import bt; bt.f(input())'
                                   6
                       /
               5
           /
       4
     /
   3
  /
 2
/
1

— Tyilo
स्रोत

आप वास्तव में बाइनरी ट्री नहीं बना रहे हैं। बस एक बाइनरी ट्री के रूप में सरणी को प्रिंट करना। ['1','2','3','4','5','6','7','8','9']सरणी का आउटपुट वह नहीं है जो आपने दिखाया था। यह 3एक सही बच्चे के रूप में होना चाहिए , 2जिसमें से एक सही बच्चा है 1जो एक मूल तत्व है।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र सवाल से: "इनपुट आपके फ़ंक्शन के तर्क के रूप में प्रदान किया जाएगा। मैं पेड़ की सटीक संरचना को निर्दिष्ट नहीं करूंगा, हालांकि यह एक वास्तविक बाइनरी पेड़ के रूप में उपयोग करने योग्य होना चाहिए।" मुझे उपयोग किए गए सरणी प्रारूप की कोई विशिष्ट परिभाषा दिखाई नहीं देती है।

— टिलो

सवाल मूल रूप से एक द्विआधारी पेड़ को छापने के बारे में है । आपके आउटपुट बाइनरी ट्री नहीं हैं। सरणी के प्रारूप का इससे कोई लेना-देना नहीं है।

— ऑप्टिमाइज़र

@Optimizer वे बाइनरी ट्री कैसे नहीं हैं? विकिपीडिया से: एक द्विआधारी वृक्ष एक पेड़ डेटा संरचना है जिसमें प्रत्येक नोड में अधिकतम दो बच्चे हैं। क्या किसी भी नोड में दो से अधिक बच्चे हैं?

— टिलो

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

— ऑप्टिमाइज़र

1

एपीएल, 125 वर्ण

{⍵{x←⍵[0;d←⌈2÷⍨1⌷⍴⍵]←↑⍺
2 1∇{x[2↓⍳↑⍴x;(⍳d)+d×⍺-1]←⍵(⍺⍺⍣t←0≠⍴⍵)2↓x[;⍳d]
x[1;d+(⌈d÷4)×¯1*⍺]←' /\'[t×⍺]}¨⍺[2 1]
x}' '⍴⍨2(×,*)≡⍵}

उदाहरण:

{⍵{x←⍵[0;d←⌈2÷⍨1⌷⍴⍵]←↑⍺
2 1∇{x[2↓⍳↑⍴x;(⍳d)+d×⍺-1]←⍵(⍺⍺⍣t←0≠⍴⍵)2↓x[;⍳d]
x[1;d+(⌈d÷4)×¯1*⍺]←' /\'[t×⍺]}¨⍺[2 1]
x}' '⍴⍨2(×,*)≡⍵}('1' ('2' ('3' ('4' ()()) ('5' ()())) ('6' ()('7' ()())))('8' ()('9' ('0' ()())())))

यहां परीक्षण किया गया।

— jimmy23013
स्रोत

क्या यह रूपांतरण लिपि भी है?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र यह नेस्टेड ऐरे इनपुट फॉर्मेट लेता है, जिसे संभवतः बाइनरी सर्च ट्री के रूप में इस्तेमाल किया जा सकता है (लेकिन मुझे कॉम्प्लेक्स के बारे में निश्चित नहीं है)। अगर मुझे कुछ और सामान्य स्वरूपों का उपयोग करना चाहिए ... शायद मैं इसे बाद में करूँगा।

— jimmy23013

@ ऑप्टिमाइज़र अब प्रश्न को फिर से पढ़ना, क्या "बाइनरी सर्च ट्री एरे" का अर्थ है गहराई से (या कुछ और) पूर्ण बाइनरी ट्री का सरणी? मुझे नहीं लगा कि यह कुछ विशिष्ट था। और इस शब्द को खोजने से कुछ उपयोगी नहीं हुआ।

— jimmy23013

en.wikipedia.org/wiki/Binary_tree#Arrays

— अनुकूलक

@ ऑप्टिमाइज़र खैर, मेरा बस यही मतलब था। लेकिन मुझे नहीं लगता कि इसे आमतौर पर "बाइनरी सर्च ट्री ऐरे" कहा जाता है, लेकिन केवल "बाइनरी ट्री का एक प्रकार का स्टोरेज"। इसे शायद कुछ स्पष्टीकरण की आवश्यकता है ... और मैं शायद इस उत्तर को बाद में ठीक करूंगा, शायद किसी अन्य भाषा में ...

— jimmy23013

0

रूबी, 265 बाइट्स

def p(t);h=Math.log(t.length,2).to_i;i=-1;j=[];0.upto(h){|d|s=2**(h-d)-1;c=2**d;if d>0;m=' '*(s+s/2)+'I'+' '*(s-s/2);1.upto(d){m+=' '+m.reverse};w=i;puts m.gsub(/I/){|o|t[w+=1]?(w%2==0?'\\':'/'):' '};end;puts (0...c).map{' '*s+(t[i += 1]or' ').to_s+' '*s}*' ';};end

@Proudhaskeller संस्करण, 269 बाइट्स

def p(t);h=Math.log(t.length,2).to_i;i=-1;j=[];0.upto(h){|d|s=(z=2**(h-d))-1;c=2**d;if d>0;m=' '*(s+z/2)+'I'+' '*(s-z/2);1.upto(d){m+=' '+m.reverse};w=i;puts m.gsub(/I/){|o|t[w+=1]?(w%2==0?'\\':'/'):' '};end;puts (0...c).map{' '*s+(t[i += 1]or' ').to_s+' '*s}*' ';};end

explaination

क्रिया संस्करण:

def p(t)
  depth = Math.log(t.length, 2).floor
  i = -1
  j = []
  (0..depth).each do |d|
    s = 2 ** (depth-d)-1
    c = 2 ** d

    if d > 0
      m = ' '*(s+s/2) + '|' + ' '*(s-s/2)
      w = i
      1.upto(d) { m += ' ' + m.reverse }
      puts m.gsub(/\|/) { |o| t[w+=1] ? (w%2==0 ? '\\' : '/') : ' ' }
    end

    puts (0...c).map{' '*s+(t[i += 1]or' ').to_s+' '*s}*' '
  end
end

उदाहरण

n = nil
p([
  1, 2, 3, 4, 5,
  n, 7, 8, 9, 0,
  1, n, n, 4, 5,
  6, 7, 8, 9, 0,
  1, 2, 3, n, n,
  n, n, 8, 9, n,
  n
])

देता है:

               1               
          /         \          
       2               3       
    /     \               \    
   4       5               7   
 /   \   /   \           /   \ 
 8   9   0   1           4   5 
/ \ / \ / \ / \         / \    
6 7 8 9 0 1 2 3         8 9

(मैंने रूपांतरण स्क्रिप्ट अभी तक नहीं लिखी है।)

— AlexRath
स्रोत

आपके स्लैश ठीक मध्य में नहीं हैं

— गर्वित हेकलर

@proudhaskeller "राउंड जो भी रास्ता आप चाहते हैं", मैंने सोचा कि यह इस तरह से कूलर लगता है। आप चाहें तो s / 2 को बदल सकते हैं (s + 1) / 2 के साथ।

— एलेक्सरथ 12

नहीं, पहली पंक्ति में स्लैश बिलकुल मध्य में नहीं है, इस पंक्ति में यह गोल होने की बात नहीं है

— गर्वित हेकलर

@proudhaskeller यदि आप s / 2 को (s + 1) / 2 से बदलते हैं, तो वे बिल्कुल बीच में हैं, लेकिन मैं अभी भी इस तरह से पसंद करता हूं क्योंकि यह सबसे बाईं और सबसे दाहिनी शाखाओं को गोल दिखता है।

— एलेक्सरथ

यह कल्पना के खिलाफ है ...

— गर्वित हेकेलर

एक बाइनरी ट्री प्रिंट करें

CJam, 100 99 बाइट्स

व्याख्या

रूपांतरण स्क्रिप्ट

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

कनवर्टर स्क्रिप्ट:

उदाहरण:

एपीएल, 125 वर्ण

रूबी, 265 बाइट्स