एक सौंदर्यवादी रूप से सुखदायक दिव्य वृक्ष का निर्माण करें

Question

एक सौंदर्यवादी रूप से मनभावन डिवाइडर ट्री इनपुट के डिवाइडर का एक पेड़ है nजो किसी भी समग्र संख्या के लिए m, दो बच्चों के नोड्स होते हैं जो विभाजक की जोड़ी होते हैं जो वर्गमूल के सबसे करीब होते हैं m। बाएं नोड का छोटा विभाजक होना चाहिए mऔर दायाँ नोड बड़ा विभाजक होना चाहिए m। पेड़ में एक प्रमुख संख्या में कोई बच्चे नहीं होना चाहिए। आपका पेड़ पाठ कला या एक छवि के रूप में हो सकता है। टेक्स्ट आर्ट आउटपुट के नियम इस प्रकार हैं।

नियमों का पालन करना

पेड़ पर नोड्स को बाहर निकालने के लिए, हमारे पास निम्नलिखित नियम हैं:

• रूट से दी गई गहराई पर नोड्स आउटपुट में टेक्स्ट की एक ही लाइन पर होना चाहिए।

  / \ नहीं / \  
 / \ / 3
२ ३ २

• बाईं ओर के नोड्स के लिए, आने वाली शाखा ऊपरी दाईं ओर होनी चाहिए यदि नोड एकल-अंक संख्या है, और, अंतिम अंक के ठीक ऊपर। उदाहरण:

 / तथा /
3 720

• दाएं नोड्स के लिए, आने वाली शाखा ऊपरी बाईं तरफ होनी चाहिए यदि नोड एक एकल अंक संख्या है, और, पहले अंक के ठीक ऊपर। उदाहरण:

\ तथा \
 3 २४३

• आउटगोइंग बाईं शाखाओं के लिए, शाखा को नंबर के बाईं ओर एक स्थान शुरू करना चाहिए। उदाहरण:

  275
 /
1 1

• आउटगोइंग राइट शाखाओं के लिए, शाखा को नंबर के दाईं ओर एक स्थान शुरू करना चाहिए। उदाहरण:

275
   \
   25

• पेड़ के समान स्तर पर किसी भी दो नोड्स के बीच न्यूनतम दो रिक्त स्थान होना चाहिए। इसी समय, पेड़ के समान स्तर पर किसी भी दो उपप्रकार के बीच जितना संभव हो उतना कम स्थान होना चाहिए।

यह पेड़ इसलिए काम नहीं करता है क्योंकि ** उपप्रकार ** बहुत करीब हैं।

        504           
       / \ _          
      / \ _         
     / \ _        
    / \ _       
   २१। 24     
  / \ _ / \ _    
 / \ _ / \ _   
३ 3 ४ ६  
        । / \ / \
        .2 2 2 3

जबकि यह पेड़ अपनी शाखाओं के बीच पर्याप्त स्थान रखता है।

         504           
        / \ _          
       / \ _         
      / \ _        
     / \ _       
    / \ _      
   21 ... 24     
  / \ ... / \    
 / \ ... / \   
३ 3 ... ४ ६  
        ... / \ / \ 
        ... २ २ २ ३

• यदि कोई दो उपप्रकार एक पेड़ पर एक साथ बहुत करीब हैं, तो उन्हें /\माता-पिता के ऊपर पेड़ की शाखाओं की एक और पंक्ति जोड़कर अलग किया जा सकता है ।

   441                              
  / \ आखिरी पंक्ति अभी तक नहीं भरी गई है और हम पहले ही अंतरिक्ष से बाहर भाग चुके हैं।
 २१ २१
/ \ / \

शाखाओं की एक और पंक्ति जोड़ें

     441                              
    / \ लगभग, लेकिन 7 और 3 एक साथ बहुत करीब हैं।
   / \ एक और पंक्ति इसे करना चाहिए।
  २१ २१
 / \ / \
3 7 3 7

शाखाओं की एक और पंक्ति जोड़ें

      441
     / \ और हम कर रहे हैं।
    / \ _
   / \ _
  २१ २१
 / \ / \
3 7 3 7

उदाहरण

एक पूर्ण उदाहरण के रूप में, 24 का दिव्य वृक्ष इस तरह दिखेगा:

     24
    /  \
   /    \
  4      6
 / \    / \
2   2  2   3

4 और 6 24 के वर्गमूल के निकटतम विभाजकों की जोड़ी है। 4 बाईं ओर है, क्योंकि यह छोटा है। अगली पंक्ति में, 2 नंबर 3 के बाईं ओर, क्योंकि यह छोटा है।

63 के लिए भाजक के पेड़ की तरह दिखना चाहिए:

  63        and NOT like this        63
 /  \                               /  \
7    9                             3   21
    / \                               /  \
   3   3                             7    3

गलत पेड़ में, 3 और 21 63 के वर्गमूल के निकटतम विभाजकों की जोड़ी नहीं हैं, और 3 और 7 को ठीक से सॉर्ट नहीं किया जाता है। 21 पर शाखा की नियुक्ति सही है, हालांकि।

42 के लिए, आपके पास होना चाहिए:

    42      and NOT        42
   /  \                   /  \
  6    7                 21   2
 / \                    /  \
2   3                  3    7

चलो 720 पर एक नजर डालते हैं। ध्यान दें कि हमें शाखाओं के पांच स्तरों की आवश्यकता है 720ताकि 24और 30उपप्रकार सही ढंग से दूरी पर हो। इसके अलावा, ध्यान दें कि 24और 30शाखाओं के दो स्तर हैं क्योंकि 4और 6बच्चों के नोड्स हैं जिन्हें सही रिक्ति की आवश्यकता है और बच्चों के नोड्स 30उसी स्तर पर होने की आवश्यकता है जैसे कि बच्चे के नोड्स 24।

           720
          /   \
         /     \
        /       \
       /         \
      /           \ 
     24           30
    /  \         /  \
   /    \       /    \
  4      6     5      6
 / \    / \          / \
2   2  2   3        2   3

चुनौती

• आपका कार्य इनपुट के लिए एक सही ढंग से तैयार सौंदर्यशास्त्र मनभावन भाजक के पेड़ का निर्माण करना है n, जहां nएक सकारात्मक पूर्णांक 1 से अधिक है।
• आपके आउटपुट में अग्रणी और अनुगामी स्थान हो सकते हैं और नए लिंक को अग्रणी और अनुगामी बना सकते हैं, लेकिन अन्यथा ऊपर दिए गए रिक्ति नियमों के अनुरूप होना चाहिए।
• आपके आउटपुट को होने की अनुमति है: पाठ कला, एक छवि (यदि आवश्यक हो तो जोड़े जाने वाले अन्य प्रारूप)।
• छवियों के लिए, सुनिश्चित करें कि आपके पेड़ के नोड्स अच्छी तरह से उभरे हुए हैं, और पेड़ में समान ऊंचाई पर नोड्स छवि में समान ऊंचाई पर हैं।
• यह कोड गोल्फ है। बाइट्स (या समतुल्य) जीत की कम से कम संख्या।

इस विचार के बारे में सोचने के लिए स्टिवी ग्रिफिन को श्रेय, और विनिर्देशन को फिर से लिखने में उनकी मदद के लिए पीटर टेलर, मार्टिन एंडर, मेगो और ईशू Iᴀ को बहुत धन्यवाद। हमेशा की तरह, किसी भी सुझाव या सुधार की बहुत सराहना की जाती है। गुड लक और गुड गोल्फिंग!

अधिक परीक्षण के मामले:

2

  4
 / \
2   2

    20
   /  \
  4    5
 / \
2   2

  323
 /   \
17   19

                        362880
                       /      \
                      /        \
                     /          \
                    /            \
                   /              \
                  /                \
                 /                  \
                /                    \
               /                      \
              /                        \
            576                        630
           /   \                      /   \
          /     \                    /     \
         /       \                  /       \
        /         \                /         \
       /           \              /           \
      /             \            /             \
     24             24          21             30
    /  \           /  \        /  \           /  \
   /    \         /    \      /    \         /    \
  4      6       4      6    3      7       5      6
 / \    / \     / \    / \                        / \
2   2  2   3   2   2  2   3                      2   3

              1286250
             /       \
            /         \
           /           \
          /             \
         /               \
      1050               1225
     /    \             /    \
    /      \           /      \
   /        \         /        \
  30        35       35        35
 /  \      /  \     /  \      /  \
5    6    5    7   5    7    5    7
    / \
   2   3

Comments

इस चुनौती के लिए धन्यवाद। मैं अब हर बार इन चीजों को बिना ड्राइंग के कल्पना कर सकता हूं: D

— कॉनर ओ'ब्रायन

क्या पेड़ को उदाहरणों की तरह देखने की जरूरत है, या क्या मैं अंतर्निहित मैथेमेटिका फ़ंक्शन का उपयोग कर सकता हूं? ऐसा लग रहा है इस , लेकिन गुणन के साथ।

— जुंगह्वान मिन ऑक्ट

@ जेएचएम मुझे पता था कि मुझे ग्राफिकल-आउटपुट टैग रखना चाहिए था । हां, आप उस बिल्ट-इन का उपयोग कर सकते हैं। मैं चुनौती संपादित करूंगा।

— शर्लक

Answer 1

पायथन 2 , 711 651 575 559 554 547 539 540 530 522 बाइट्स

इस उत्तर को लिखने की कोशिश करने के चार महीने बाद, एक दीवार में दौड़ते हुए, एक हफ्ते के लिए छोड़ कर, कुल्ला, दोहराना, मैंने आखिरकार इस चुनौती के लिए एक उचित ASCII कला उत्तर समाप्त कर दिया है। जो कुछ बचा है वह गोल्फिंग है, और इसलिए, गोल्फिंग सुझावों का बहुत स्वागत है। इसे ऑनलाइन आज़माएं!

गोल्फ: -60 बाइट्स से कुछ अक्सर इस्तेमाल किए जाने वाले कार्यों का नाम बदलने और परिणाम कैसे लौटाया जाता है। -73 बाइट्स को बदलने से कि कैसे उपटैब्स की ऊंचाइयों की जांच की जाती है, रिक्ति चर की गणना कैसे की जाती है, और परिणाम कैसे लौटाया जाता है। FlipTack के isdigit()प्रतिस्थापन से -3 बाइट्स । -16 बाइट्स गोल्फिंग कि isdigit()रिप्लेसमेंट और भी "" के साथ E। मामूली सुधार से -5 बाइट्स और पायथन 3 से पायथन में परिवर्तित 2. परिणाम कैसे लौटाया जाता है इसे संशोधित करने के लिए -7 बाइट्स से। -8 बाइट्स Aको परिभाषित करने, कैसे बदलनेTW , कैसे परिभाषित किया गया है, और जोड़ना , इस परिकल्पना का उपयोग करते हुए कि अपने समकक्ष की तुलना में कम से कम एक लंबी शाखा के साथ किसी भी उपप्रकार, आवश्यक रूप से अपने समकक्ष की तुलना में समग्र रूप से लंबा है , निकालनाQकुल मिलाकर, और परिणाम कैसे लौटाए गए हैं इसका संपादन। -10 का उपयोग करने से बाइट्स A<10के बजाय L(S(A))<2के लिए Aऔर B। -8 बाइट्स डिफॉल्ट Hको बदलने से [0]क्योंकि कोड म्यूट करने योग्य डिफॉल्ट तर्कों की समस्या को कभी म्यूट नहीं करता है H, यह बदलने के बजाय कि कैसे qउपयोग (B>9)करने से परिभाषित किया जाता है 1-(B<10), pपूरी तरह से हटाकर , और Fएक प्रतिस्थापन के रूप में बनाया जाता है p+q-M।

बग को ठीक करता है: परिकल्पना गलत थी, प्रतिपक्ष में 11**9 = 2357947691। +1 बाइट

G=range;L=len;E=" "
def t(n,H=[0]):
 A=max(z*(n%z<1)for z in G(1,int(n**.5)+1));B=n/A;Z=str(n);M=L(Z)
 if A<2:return[Z]
 T=max([i for i in G(L(w))if"/"not in w[i]]for w in(t(A),t(B)));V=H[1:]or[T[k+1]-T[k]-1for k in G(L(T)-1)];x=t(A,V);y=t(B,V);P=x[0].rindex(str(A)[-1])+(A<10);q=y[0].index(str(B)[0])+(B>9);F=L(x[0])-P+q-M;h=H[0]or(F+M%2+2)/2or 1;return[E*(P+J)+(J<h and"/"+E*(2*h+M-2*J-2)+"\\"or Z)+E*(L(y[0])-q+J)for J in G(h,-1,-1)]+[(E*(2*h-F)).join(I<L(w)and w[I]or E*L(w[0])for w in(x,y))for I in G(max(L(x),L(y)))]

व्याख्या

पूरे समारोह को लगभग चार चरणों में उबाला जा सकता है:

1. की सबसे बड़ी विभाजक जोड़ी निर्धारित करें n, Aऔर B।
2. की subtrees बनाने Aऔर B, के रूप में की जरूरत redrawing।
3. उप-स्थानों के बीच जाने वाले रिक्त स्थान की संख्या निर्धारित करें।
4. नए भाजक के पेड़ को ड्रा और वापस करें।

मैं क्रम में प्रत्येक चरण से गुजरूंगा।

चरण 1. यह सबसे आसान कदम है, काफी स्पष्ट रूप से। zविभाज्यता के लिए 1 और वर्गमूल के बीच हर संख्या की जाँच करें और nसबसे बड़े zऔर n//zउस मैच को पकड़ो । वापसी सिर्फ str(n)अगर nप्रधानमंत्री है (या तो A==1या B==n)

चरण 2. का subtrees ड्रा Aऔर Bऔर की संख्या प्राप्त /\subtrees में नोड्स के बीच शाखाओं। ऐसा करने के लिए, हमें प्रत्येक चरण के सूचकांक मिलते हैं, जिनमें अंक होते हैं, सूचकांकों के पहले अंतर प्राप्त करते हैं, और फिर से घटाते हैं। एक बार जब हमारे पास ऊंचाइयां होती हैं, तो हम सबसे बड़ी पाने के लिए उनकी तुलना करते हैं, और नई ऊंचाइयों के साथ उपप्रकार को फिर से जोड़ते हैं।

मुझे इस बात पर संदेह है कि जो सबट्री अधिक लम्बी है, उसकी शाखाएँ हमेशा छोटी सबट्री पर शाखाओं के बराबर या बराबर होती हैं, और मैं इसका उपयोग कोड को गोल्फ करने के लिए कर सकता हूँ, लेकिन मेरे पास अभी तक इसका कोई प्रमाण नहीं है। में प्रतिपक्ष 11**9 = 2357947691।

चरण 3. इस कदम को लिखने में महीनों लग गए। चरण 2 को लिखने और डीबग करने में कुछ दिन लगे, लेकिन रिक्ति के लिए सही सूत्र खोजने में युग लग गए। मैं देखूंगा कि क्या मैं कुछ पैराग्राफ में पता लगा सकता हूं कि क्या मैं संक्षेपण कर सकता हूं। ध्यान दें कि इस स्पष्टीकरण में कुछ कोड तब से असली कोड से बाहर हो गए हैं।

सबसे पहले, p, q, h, P, Q, sऔर M। pबाईं शाखा के /अंत से बाएँ उपशीर्षक के दाईं ओर के वर्णों की संख्या है । qदाईं ओर के दायें से बायें छोर से दायीं शाखा के अंत तक वर्णों की संख्या है /। hजड़ और उपप्रकार के बीच की शाखाओं की संख्या है। Pऔर Qबस के व्युत्क्रम हैं pऔर जड़ तक शाखाओं के qचारों ओर रिक्त स्थान रखने के लिए उपयोगी हैं । रिक्त स्थान की संख्या है जो दो उपप्रकारों के बीच जुड़ती है। सबसे सरल है; की लंबाई है । रेखांकन:/\nsMn

            M
           ---
           720           
 |        /   \          
 |       /     \         
h|      /       \        
 |     /         \       
 |    /           \      
   P    p    s   q   Q   
------______---____------
     24           30     
    /  \         /  \    
   /    \       /    \   
  4      6     5      6  
 / \    / \          / \ 
2   2  2   3        2   3

यह निर्धारित करने pका सूत्र यह है: p = len(x[0]) - x[0].rindex(str(A)[-1]) - (A<10)लंबाई, ए में अंतिम वर्ण का शून्य-सूचकांक, शून्य से एकल-अंक के लिए एक सुधार A।

यह निर्धारित करने qका सूत्र यह है: q = y[0].index(str(B)[0]) + (B>9)बी में पहले वर्ण का सूचकांक, साथ ही शून्य-अनुक्रमण के लिए एक सुधार, एकल-अंक के लिए एक सुधार शून्य B(एकाधिक अंकों के लिए एक सुधार में संयुक्त B)।

निर्धारित करने के लिए सूत्र hयह है: h = H[0] or (p+q+M%2+2-M)//2 or 1। या तो हम एक पूर्वनिर्धारित से पकड़ते हैं Hजिसका अर्थ है कि हम पेड़ को फिर से खोल रहे हैं, हम उपयोग करते हैं (from_the_left + from_the_right + parity_space + 2 - len(root)) // 2), या हम शाखा स्तर की न्यूनतम संख्या का उपयोग करते हैं, 1।

निर्धारित करने के लिए सूत्र sयह है: s = 2*h+M-p-q। हम अपनी व्यापकता में जड़ की शाखाओं के बीच की जगहों की संख्या को घटाते pऔर घटाते हैं ।q2*h + M

चरण 4. और अंत में हम इसे एक साथ रख देते हैं। पहले हम जड़ बनाने के लिए, [" "*(P+h)+Z+" "*(Q+h)]तो हम शाखाओं में subtrees करने के लिए नीचे डाल दिया, [" "*(P+J)+"/"+" "*(2*h+M-2*J-2)+"\\"+" "*(Q+J)for J in G(h)][::-1]और अंत में हम अपने को ठीक से स्थान दिया गया है subtrees में, डाल [(" "*(2*h+M-p-q)).join([(I<L(w)and w[I]or" "*L(w[0]))for w in(x,y)])for I in G(max(L(x),L(y)))]।

Et voilà! हम खुद को एक सौंदर्यवादी रूप से मनभावन भाजक पेड़ है!

Ungolfing:

def tree(n, H=[0]):
    A = max(z for z in range(1, int(n**.5)+1) if n%z<1)
    B = n/A
    Z = str(n)
    M = len(Z)
    if A < 2:
        return [Z]

    # redraw the tree so that all of the numbers are on the same rows
    x = tree(A)
    y = tree(B)
    for W in [x, y]:
        T = [i for i in range(len(W)) if "/" not in W[i]]
    V = H[1:] or [T[k+1]-T[k]-1 for k in range(len(T)-1)]
    x = tree(A, V)
    y = tree(B, V)

    # get the height of the root from the two trees
    P = x[0].rindex(str(A)[-1]) + (A < 10)
    p = len(x[0]) - P
    q = y[0].index(str(B)[0]) + (B > 9)
    Q = len(y[0]) - q
    h = hs[0] or (p+q+M%2+2-M)/2 or 1

    # and now to put the root down
    R = []
    s = 2*h+M-p-q
    for I in range(max(len(x),len(y))):
        c = I<len(x) and x[I] or " "*len(x[0])
        d = I<len(y) and y[I] or " "*len(y[0])
        R += c + " "*s + d,
    for J in range(h, -1, -1):
        if J<h:
            C = "/" + " "*(2*h+M-2*J-2) + "\\"
        else:
            C = Z
        R += [" "*(P+J) + C + " "*(Q+J)]
    return R

Comments

क्या आपकी isdigitजाँच हो सकती है '/'<x[i].strip()[0]<':'?

— फ्लिपकार्ट

Answer 2

मैथेमेटिका, 96 86 81 79 78 बाइट्स

धन्यवाद @MartinEnder 2 बाइट्स के लिए।

TreeForm[If[PrimeQ@#,#,#0/@(#2[#,#2/#]&[Max@Nearest[Divisors@#,#^.5],#])]&@#]&

आउटपुट इस तरह दिखता है:

व्याख्या

Max@Nearest[Divisors@#,#^.5]

इनपुट के विभाजकों की सूची तैयार करें। इनपुट के वर्गमूल के निकटतम तत्व का पता लगाएं। ( Maxआउटपुट को समतल करने के लिए है)

#2[#,#2/#]&

ऊपर पाए गए भाजक द्वारा इनपुट को विभाजित करके अन्य भाजक का पता लगाएं, परिणाम के प्रमुख के रूप में इनपुट लागू करें।

#0/@

प्रक्रिया को दोहराएं।

If[PrimeQ@#,#, ... ]

यदि इनपुट प्रधान है, तो कुछ भी न करें।

TreeForm

आउटपुट स्वरूपित करें।

संपादित करें: अधिक सौंदर्यवादी रूप से मनभावन संस्करण (258 बाइट्स)

TreeForm[#/.{a_,_,_}:>a,VertexRenderingFunction->(#2~Text~#&),VertexCoordinateRules->Cases[#,{_,_},Infinity,Heads->True]]&@(If[PrimeQ@#,{##},{##}@@#0@@@({{#,#3-#4{1,√3}/2,#4/2},{#2/#,#3-#4{-1,√3}/2,#4/2}}&[Max@Nearest[Divisors@#,√#],##])]&[#,{0,0},1])&

आउटपुट इस तरह दिखता है:

Comments

Sqrt@#-> #^.5(बेशक तब आप के लिए infix संकेतन का उपयोग नहीं कर सकते, Nearestलेकिन तब आप का उपयोग कर सकते हैं Max@)।

— मार्टिन एंडर

यह नियमों का पालन करता है, लेकिन यह पेड़ सौंदर्यवादी रूप से मनभावन एक्सडी से दूर है

— बीटा डिके

सुंदरता देखने वाले की नजर में है :)

— नेल्सन

मुझे यकीन नहीं है कि यह वैध है। उदाहरणों के विपरीत, प्रत्येक पंक्ति पर नोड समान रूप से नहीं हैं। इसके अतिरिक्त, लाइनें सही अंक से कनेक्ट नहीं होती हैं।

— Mego

@Mego खैर, ओपी ने कहा कि यह वैध था।

— आर। कप

Answer 3

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

≔⟦⟦Ｎ⁰θ⁰¦⁰⟧⟧θＦθ«≔§ι⁰ζ≔⌈Ｅ…·²Ｘζ·⁵∧¬﹪ζκκη¿η«Ｆ⟦η÷ζη⟧«≔⟦κ⊕§ι¹Ｉκ⁰¦⁰⟧κ⊞ικ⊞θκ»⊞υι»»≔…⁰⌈Ｅθ§ι¹ηＦ⮌竧≔ηι⊕⌈⟦⁰⌈Ｅυ∧⁼§κ¹ι÷Σ⟦¹§§κ⁵¦⁴‹⁹§§κ⁵¦⁰§§κ⁶¦³‹⁹§§κ⁶¦⁰±Ｌ§κ²⟧²⟧ＦυＦ²§≔κ⁺³λ⁺⁺§ηι∨⊖Ｌ§§κ⁺⁵벦¹§§κ⁺⁵λ⁺³λ»Ｆυ«§≔§ι⁵¦³⁻⁻§ι³§η§ι¹∨⊖Ｌ§§ι⁵¦²¦¹§≔§ι⁶¦³⁻⁺⁺§ι³Ｌ§ι²§η§ι¹‹⁹§§ι⁶¦⁰»Ｆ⊕Ｌη«Ｆθ«Ｆ⁼§κ¹ι«←⸿Ｍ§κ³→Ｆ‹⁵Ｌκ«↙Ｐ↙§ηι↗»§κ²↓Ｆ‹⁵ＬκＰ↘§ηι»»Ｍ⊕§ηι↓

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

u = []; // predefined variable, used as list of branches
q = [[+s, 0, s, 0, 0]]; // list of nodes starts with the root.
for (i of q) { // iterate nodes, includes new nodes
    z = i[0]; // get node value
    h = Math.max(...[...Array(Math.floor(z ** 0.5) + 1).keys()].slice(2).filter(
        k => z % k < 1)); // find largest factor not above square root
    if (h) {
        for (k of [h, z / h]) {
            k = [k, i[1] + 1, `${k}`, 0, 0]; // create child node
            i.push(k); // add each child to parent (indices 5 and 6)
            q.push(k); // and to master nodelist
        }
        u.push(i);
    }
}
h = new Array(Math.max(...q.map(i => i[1]))); // list of branch heights
for (i = h.length; i --> 0; ) {
    // find branch height needed to space immediate children apart at this depth
    h[i] = 1 + Math.max(...u.map(k => k[1] == j && // filter on depth
        1 + k[5][3] + (k[5][0] > 9) + k[6][2] + (k[6][0] > 9) - k[2].length
        >> 1)); // current overlap, halved, rounded up
    // calculate the new margins on all the nodes
    for (k of u) {
        k[3] = h[i] + (k[5][2].length - 1 || 1) + k[5][3]; // left
        k[4] = h[i] + (k[6][2].length - 1 || 1) + k[6][4]; // right
    }
}
// calculate the absolute left margin of all the nodes under the root
for (i of u) {
    i[5][3] = i[3] - h[i[1]] - (i[5][2].length - 1 || 1);
    i[6][3] = i[3] + i[2].length + h[i[1]] - (i[6][0] > 9);
}
// print the nodes (sorry, no transliteration available)