18

এসও সম্পর্কে সাম্প্রতিক প্রশ্নে অনুপ্রাণিত ...

নিম্নলিখিত বিন্যাসে একটি বাইনারি গাছ মুদ্রণ করতে একটি ফাংশন লিখুন:

আউটপুটে নোডের একটি লাইন থাকা উচিত, তারপরে একটি রেখা /এবং \অক্ষর যুক্ত হবে যা সম্পর্কগুলি নির্দেশ করে, তারপরে নোডের লাইন ইত্যাদি by
আপনি ধরে নিতে পারেন যে সমস্ত নোড একক চরিত্র হিসাবে উপস্থাপনযোগ্য।
নিম্নতম স্তরের সংলগ্ন নোডগুলি কমপক্ষে একটি স্পেস দ্বারা পৃথক করা উচিত, নোডগুলি আরও উপরে যথাযথ হিসাবে পৃথক করা উচিত।
দুটি শিশু সহ নোডগুলি তাদের সরাসরি বাচ্চাদের মাঝখানে ঠিক রেখে দেওয়া উচিত।
সম্পর্কের টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টুকরো টানা পিতা-মাতার এবং উপযুক্ত সন্তানের মধ্যে (আপনি যেভাবেই চান রাউন্ড) হওয়া উচিত।

ইনপুট:

ইনপুটটি আপনার ফাংশনের আর্গুমেন্ট হিসাবে সরবরাহ করা হবে। আমি গাছটির সঠিক কাঠামো নির্দিষ্ট করব না, তবে এটি অবশ্যই একটি সত্য বাইনারি গাছ হিসাবে ব্যবহারযোগ্য হবে। কোনও "গাছগুলিকে আমার প্রোগ্রামে স্ট্রিং হিসাবে কাকতালীয়ভাবে প্রত্যাশিত আউটপুটটির মতো দেখানো হচ্ছে না"।

আপনি কোনও আউটপুট স্ট্রিমে মুদ্রণ করতে পারেন বা আপনার পছন্দ অনুযায়ী আউটপুট যুক্ত স্ট্রিংটি ফিরে আসতে পারেন।

সবচেয়ে সংক্ষিপ্ত কোডের জন্য পয়েন্টস, তবে আমি 90%-সংক্ষিপ্ত-সংক্ষিপ্ত একটির চেয়ে সম্পূর্ণ পরিশ্রমী দীর্ঘ সমাধান পছন্দ করি।

অনুগ্রহের জন্য আপডেট:

অনুগ্রহের জন্য, আমি (অপ্টিমাইজার) সামান্য পরিবর্তন করছি:

ইনপুটটি STDIN, ARGV বা ফাংশন যুক্তি হতে পারে।
আউটপুট STDOUT এ থাকা (বা জেএসের console.logজন্য) হওয়া দরকার
আপনি ধরে নিতে পারেন ইনপুটটি অ্যারের আকারে, প্রাক্তন হিসাবে। [1,2,3]অথবা[1 2 3]

আপডেট 2 - বাইনারি ট্রিটি আসলে একটি বাইনারি অনুসন্ধান গাছ হওয়া উচিত। যেহেতু আমি প্রথমে এটি উল্লেখ করি নি, তাই আমি ব্যবহারকারীদের একটি সাধারণ অ্যারেটিকে বাইনারি অনুসন্ধানের ট্রি অ্যারে রূপান্তর করতে আলাদা প্রোগ্রাম হিসাবে বিবেচনা করার অনুমতি দেব এবং চূড়ান্ত বাইট গণনাটি কেবল অ্যারেটিতে আর্গুমেন্ট হিসাবে গ্রহণ করে এটি মুদ্রণ করবে বাইনারি গাছের মতো

code-golf ascii-art binary-tree

— বেনামা।
সূত্র

আমাদের কি বেশ কয়েকটি সম্পর্কের স্ল্যাশ ব্যবহার করা উচিত? আমরা কি ন্যূনতম সংখ্যক স্ল্যাশ ব্যবহার করব? একটি বাম বাচ্চা এবং একক ডান সন্তানের মধ্যে পার্থক্য করা উচিত? প্রতিটি আউটপুট লাইনে শীর্ষস্থানীয় স্থান রাখা ভাল?

গাছটি সম্পূর্ণ না হলে আমরা কী করব (কিছু এন এর জন্য 2 ^ n-1 নোড)? কিছু নোডের (কোনটি?) একমাত্র সন্তান রয়েছে। তবে যদি আমাদের কেবলমাত্র একটি সন্তানের সাথে নোড রাখার অনুমতি দেওয়া হয় তবে অবক্ষয়যুক্ত গাছটি তৈরি করা সহজ (1-2 এবং ৩-৩-৩-৩ নীচে এবং ডানদিকে, বলুন)।

— কিথ র্যান্ডাল

আপনি এটি কিভাবে বড় সংখ্যার জন্য আঁকেন? উদাহরণস্বরূপ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

সিজোম, 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
সূত্র

আপনি কেবলমাত্র আরও দুটি বাইট যুক্ত করতে পারেন এবং অক্ষরের পরিবর্তে যথাযথ পূর্ণসংখ্যা হিসাবে রূপান্তর স্ক্রিপ্টের ইনপুটটি তৈরি করতে পারেন :)

— অপ্টিমাইজার

উভয় সমর্থন করার জন্য @ অপ্টিমাইজার সম্পাদিত আমি মনে করি অক্ষরগুলি আরও অর্থবোধ করে যেহেতু এটি কেবল একটি একক চরিত্রের সাথে নোডের নামগুলিকে সমর্থন করে। একক সংখ্যা সংখ্যার চেয়ে অনেক বেশি অক্ষর রয়েছে।

— জিমি 23013

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যার মধ্যে একটি মূল উপাদান।

— অপ্টিমাইজার

@ অপ্টিমাইজার প্রশ্ন থেকে: "ইনপুটটি আপনার ক্রিয়াকলাপের জন্য একটি আর্গুমেন্ট হিসাবে সরবরাহ করা হবে I আমি গাছটির সঠিক কাঠামো নির্দিষ্ট করব না, তবে এটি অবশ্যই একটি সত্য বাইনারি গাছ হিসাবে ব্যবহারযোগ্য হবে be" ব্যবহৃত অ্যারে বিন্যাসের একটি নির্দিষ্ট সংজ্ঞা দেখতে পাচ্ছি না।

— টাইলো

প্রশ্নটি মূলত বাইনারি ট্রি প্রিন্ট করার বিষয়ে । আপনার ফলাফলগুলি বাইনারি গাছ নয়। অ্যারের ফর্ম্যাট এর সাথে কিছু করার নেই।

— অপ্টিমাইজার

@ অপ্টিমাইজার কীভাবে তারা বাইনারি গাছ নয়? উইকিপিডিয়া থেকে: বাইনারি ট্রি একটি গাছের ডেটা কাঠামো যাতে প্রতিটি নোডে সর্বাধিক দুটি শিশু থাকে। কোন নোডের দুটিরও বেশি শিশু রয়েছে?

— টাইলো

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.wikedia.org/wiki/Binary_tree#Arrays

— Optimizer

@ অপ্টিমাইজার ওয়েল, আমি যা বলছিলাম ঠিক সেটাই ছিল। তবে আমি মনে করি না এটি সাধারণত "বাইনারি অনুসন্ধান ট্রি অ্যারে" নামে পরিচিত তবে কেবল "বাইনারি গাছের এক ধরণের অ্যারে স্টোরেজ"। সম্ভবত এটির কিছু ব্যাখ্যা দরকার ... এবং আমি সম্ভবত এই উত্তরটি কয়েক দিন পরে ঠিক করতে পারব, সম্ভবত অন্য ভাষায় ...

— 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

@ প্রসাদহসকলার সংস্করণ, 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
সূত্র

আপনার স্ল্যাশগুলি ঠিক মাঝখানে নয়

— গর্বিত হাসেলেলার

@ প্রফেসহেস্কিলার "আপনি যেদিকেই চান", আমি ভেবেছিলাম এটিকে আরও শীতল দেখাচ্ছে। আপনি চাইলে s / 2 (s + 1) / 2 এর সাথে প্রতিস্থাপন করতে পারেন।

— অ্যালেক্সারথ

না, প্রথম সারিতে থাকা স্ল্যাশগুলি তিনি ঠিক মাঝখানে নেই, এই সারিতে এটি গোলাকার বিষয় নয়

— গর্বিত হাসেলেলার

@ প্রফাসহেস্কিলার আপনি যদি s / 2 এর সাথে (s + 1) / 2 প্রতিস্থাপন করেন তবে সেগুলি ঠিক মাঝখানে রয়েছে তবে আমি এখনও এইভাবে পছন্দ করি কারণ এটি বাম দিকের এবং ডানদিকের শাখাগুলিকে গোলাকার দেখায়।

— অ্যালেক্সারথ

এটা

— অনুমানের

একটি বাইনারি ট্রি মুদ্রণ করুন

সিজোম, 100 99 বাইট

ব্যাখ্যা

রূপান্তর লিপি

পাইথন 2, 411 বাইট

রূপান্তরকারী লিপি:

উদাহরণ:

এপিএল, 125 টি অক্ষর

রুবি, 265 বাইট