ต้นไม้หารสกอร์ที่ชื่นชอบเป็นต้นไม้แห่งหารของใส่nว่าสำหรับจำนวนคอมโพสิตใด ๆmมีสองโหนดเด็กที่มีคู่ของตัวหารที่ใกล้เคียงกับรากที่สองmของ โหนดซ้ายควรจะเป็นตัวหารขนาดเล็กและโหนดที่เหมาะสมควรจะเป็นตัวหารขนาดใหญ่ของm mจำนวนเฉพาะในต้นไม้ไม่ควรมีโหนดลูก ต้นไม้ของคุณอาจอยู่ในรูปแบบของข้อความหรือรูปภาพ กฎสำหรับการส่งออกข้อความศิลปะมีดังนี้

กฎการเว้นวรรค

ในการเว้นช่องว่างของโหนดบนต้นไม้เรามีกฎต่อไปนี้:

• โหนดที่ระดับความลึกที่กำหนดจากรูทควรอยู่ในบรรทัดข้อความเดียวกันในเอาต์พุต

  / \ Not / \  
 / \ / 3
2 3 2

• สำหรับโหนดด้านซ้ายสาขาที่เข้ามาควรจะอยู่ทางด้านขวาบนหากโหนดนั้นเป็นตัวเลขหลักเดียวมิฉะนั้นจะอยู่เหนือหลักสุดท้าย ตัวอย่าง:

 / และ /
3 720

• สำหรับโหนดที่ถูกต้องสาขาที่เข้ามาควรจะอยู่ทางด้านซ้ายบนหากโหนดนั้นเป็นตัวเลขหลักเดียวมิฉะนั้นจะอยู่เหนือหลักแรก ตัวอย่าง:

\ AND \
 7 243

• สำหรับสาขาซ้ายออกสาขาควรเริ่มต้นหนึ่งช่องทางด้านซ้ายของหมายเลข ตัวอย่าง:

  275
 /
11

• สำหรับสาขาด้านขวาขาออกสาขาควรเริ่มต้นหนึ่งช่องทางด้านขวาของหมายเลข ตัวอย่าง:

275
   \
   25

• ใด ๆ ที่สองโหนดในระดับเดียวกันของต้นไม้ควรมีอย่างน้อยสองช่องว่างระหว่างพวกเขา ในเวลาเดียวกันทรีย่อยสองอันในระดับเดียวกันของทรีควรมีช่องว่างน้อยที่สุดระหว่างที่เป็นไปได้

ต้นไม้นี้ใช้งานไม่ได้เพราะต้นไม้ย่อย ** อยู่ใกล้เกินไป

        504           
       / \          
      / \         
     / \        
    / \       
   21. 24     
  / \ / \    
 / \ / \   
3 7. 4 6  
        . / \ / \
        .2 2 2 3

ในขณะที่ต้นไม้ต้นนี้มีพื้นที่เพียงพอระหว่างกิ่งของมัน

         504           
        / \          
       / \         
      / \        
     / \       
    / \      
   21 ... 24     
  / \ ... / \    
 / \ ... / \   
3 7 ... 4 6  
        ... / \ / \ 
        ... 2 2 2 3

• หากทรีย่อยสองอันอยู่ติดกันบนต้นไม้มากเกินไปพวกมันสามารถแยกออกจากกันได้โดยการเพิ่มกิ่งอีกแถวหนึ่ง/\ลงในต้นไม้ที่อยู่เหนือพ่อแม่

   441                              
  / \ แถวสุดท้ายยังไม่ได้กรอกและเรามีพื้นที่ว่างหมดแล้ว
 21 21
/ \ / \

เพิ่มสาขาอีกแถว

     441                              
    / \ เกือบ แต่ 7 และ 3 อยู่ใกล้กันมากเกินไป
   / \ อีกหนึ่งแถวควรทำ
  21 21
 / \ / \
3 7 3 7

เพิ่มสาขาอีกแถว

      441
     / \ และเราเสร็จแล้ว
    / \
   / \
  21 21
 / \ / \
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และ30subtrees ถูกต้อง นอกจากนี้ทราบว่า24และ30มีสองระดับของสาขาเพราะ4และ6มีโหนดเด็กที่ต้องการระยะห่างที่ถูกต้องและโหนดเด็กของความต้องการที่จะอยู่ในระดับเดียวกับโหนดเด็ก3024

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

ความท้าทาย

• งานของคุณคือการสร้างแผนภูมิตัวหารที่ชื่นชอบการเว้นระยะอย่างถูกต้องสำหรับอินพุตnซึ่งnเป็นจำนวนเต็มบวกมากกว่า 1
• ผลลัพธ์ของคุณอาจมีช่องว่างนำหน้าและต่อท้ายและขึ้นบรรทัดใหม่นำหน้าและต่อท้าย แต่จะต้องสอดคล้องกับกฎการเว้นวรรคที่ระบุไว้ด้านบน
• เอาต์พุตของคุณได้รับอนุญาตให้เป็น: text art, รูปภาพ (รูปแบบอื่น ๆ ที่จะเพิ่มหากจำเป็น)
• สำหรับรูปภาพตรวจสอบให้แน่ใจว่าโหนดของต้นไม้ของคุณเว้นระยะห่างกันและโหนดที่ความสูงเดียวกันในต้นไม้นั้นมีความสูงเท่ากันในรูปภาพ
• นี่คือรหัสกอล์ฟ จำนวนไบต์ที่น้อยที่สุด (หรือเทียบเท่า) จะชนะ

ขอขอบคุณ Stewie Griffin ที่คิดถึงแนวคิดนี้และขอขอบคุณ Peter Taylor Martin Ender, Mego และEᴀsᴛᴇʀʟʏ I many ที่ให้ความช่วยเหลือในการเขียนข้อกำหนดใหม่ ตามปกติข้อเสนอแนะหรือการแก้ไขจะได้รับการชื่นชมมาก ขอให้โชคดีและการเล่นกอล์ฟที่ดี!

กรณีทดสอบเพิ่มเติม:

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

Python 2 , 711 651 575 559 554 547 539 540 530 522 ไบต์

หลังจากสี่เดือนของการพยายามที่จะเขียนคำตอบนี้วิ่งเข้าไปในกำแพงทิ้งไว้เป็นเวลาหนึ่งสัปดาห์ล้างทำซ้ำในที่สุดฉันก็เสร็จคำตอบศิลปะ ASCII ที่เหมาะสมสำหรับความท้าทายนี้ สิ่งที่เหลืออยู่ก็คือการเล่นกอล์ฟดังนั้นคำแนะนำการเล่นกอล์ฟก็ยินดีอย่างยิ่ง ลองออนไลน์!

Golfs: -60 ไบต์จากการเปลี่ยนชื่อฟังก์ชั่นที่ใช้บ่อยและเปลี่ยนวิธีส่งคืนผลลัพธ์ -73 ไบต์จากการเปลี่ยนวิธีการตรวจสอบความสูงของทรีย่อยวิธีคำนวณตัวแปรระยะห่างและวิธีการส่งคืนผลลัพธ์ -3 ไบต์จากการisdigit()แทนที่ของ FlipTack -16 ไบต์เล่นกอล์ฟที่isdigit()ทดแทนให้ดียิ่งขึ้นและแทนที่ "" Eกับ -5 ไบต์จากการปรับปรุงเล็กน้อยและเปลี่ยนจาก Python 3 เป็น Python 2 -7 ไบต์จากการปรับเปลี่ยนวิธีการส่งคืนผลลัพธ์ -8 ไบต์จากการเปลี่ยนแปลงเล็กน้อยเป็นวิธีการAกำหนดเปลี่ยนวิธีการTกำหนดและการเพิ่มWโดยใช้สมมุติฐานว่าทรีย่อยใด ๆ ที่มีสาขาย่อยอย่างน้อยหนึ่งสาขาที่ยาวกว่าคู่จะต้องมีความยาวมากกว่าการเอาออกQทั้งหมดและแก้ไขวิธีการส่งคืนผลลัพธ์ -10 ไบต์จากการใช้A<10แทนL(S(A))<2สำหรับและA B-8 ไบต์จากการเปลี่ยนค่าเริ่มต้นHไป[0]ตั้งแต่รหัสหลีกเลี่ยงปัญหาของการขัดแย้งเริ่มต้นที่ไม่แน่นอนโดยไม่เคยกรรมวิธีHการเปลี่ยนแปลงวิธีการที่qถูกกำหนดโดยใช้(B>9)แทนการ1-(B<10)ลบpโดยสิ้นเชิงและการสร้างทดแทนสำหรับFp+q-M

แก้ไขข้อผิดพลาด:สมมติฐานผิด counterexample 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, และAB
2. ทำทรีย่อยของAและBวาดใหม่ตามต้องการ
3. กำหนดจำนวนช่องว่างที่ควรไประหว่างทรีย่อย
4. วาดและส่งคืนต้นไม้ตัวหารใหม่

ฉันจะผ่านแต่ละขั้นตอนตามลำดับ

ขั้นตอนที่ 1นี่คือขั้นตอนที่ง่ายที่สุดค่อนข้างตรงไปตรงมา ตรวจสอบทุกหมายเลขzระหว่าง 1 ถึงรากที่สองเพื่อหาการหารnและจับที่ใหญ่ที่สุดzและn//zที่ตรงกัน ส่งคืนเฉพาะstr(n)ถ้าnเป็นไพรม์ (อย่างใดอย่างหนึ่งA==1หรือB==n)

ขั้นตอนที่ 2วาด subtrees of AและBรับจำนวน/\กิ่งระหว่างโหนดใน subtrees ในการทำเช่นนี้เราจะได้ดัชนีของทุกขั้นตอนที่มีตัวเลขอยู่ในนั้นรับความแตกต่างแรกของดัชนีและลบ 1 อีกครั้ง เมื่อเรามีความสูงเราจะเปรียบเทียบพวกมันเพื่อให้ได้ขนาดที่ใหญ่ที่สุดและวาดแผนผังย่อยด้วยความสูงใหม่

ฉันสงสัยว่าทรีย่อยที่สูงโดยรวมมักมีกิ่งก้านสาขายาวหรือเท่ากับกิ่งก้านบนทรีย่อยสั้นและฉันสามารถใช้มันเพื่อตีกอล์ฟ แต่ฉันยังไม่มีข้อพิสูจน์ counterexample 11**9 = 2357947691ใน

ขั้นตอนที่ 3 ขั้นตอนนี้คือสิ่งที่ต้องใช้เวลาหลายเดือนในการเขียน ขั้นตอนที่ 2 ใช้เวลาสองสามวันในการเขียนและดีบัก แต่การค้นหาสูตรที่เหมาะสมสำหรับระยะห่างนั้นใช้เวลานาน ฉันจะดูว่าฉันสามารถย่อสิ่งที่ฉันคิดออกเป็นสองสามย่อหน้าหรือไม่ โปรดทราบว่ารหัสบางส่วนในคำอธิบายนี้ได้ถูกนำออกมาจากรหัสจริง

ครั้งแรกp, q, h, P, Q, และs คือจำนวนอักขระจากส่วนท้ายของกิ่งด้านซ้ายถึงด้านขวาของทรีย่อยด้านซ้าย คือจำนวนของตัวละครจากปลายด้านซ้ายของต้นไม้ย่อยขวาที่ส่วนท้ายของสาขาที่เหมาะสมที่ คือจำนวนกิ่งระหว่างรูทและทรีย่อย และเป็นเพียงแปรผกผันของและและมีประโยชน์สำหรับการวางช่องว่างรอบสาขาถึงราก คือจำนวนช่องว่างที่บวกระหว่างสอง subtrees ง่ายที่สุด มันเป็นความยาวของ ใส่กราฟิก:Mp/q/hPQpq/\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 ลบการแก้ไขสำหรับAs หลักเดียว

สูตรสำหรับการพิจารณาqคือ: q = y[0].index(str(B)[0]) + (B>9)ดัชนีของอักขระตัวแรกใน B บวกการแก้ไขสำหรับการทำดัชนีศูนย์ลบการแก้ไขสำหรับBs หลักเดียว(รวมเป็นหนึ่งการแก้ไขสำหรับหลายหลักBs)

สูตรในการพิจารณาคือ: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)))]เว้นระยะห่างอย่างถูกต้องของเรา

และอื่น ๆ ! เรามีต้นไม้ตัวหารที่น่าพอใจ!

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

Mathematica, 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])&

ผลลัพธ์มีลักษณะดังนี้:

ถ่าน , 302 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เนื่องจากเวอร์ชัน verbose เป็น verbose มากเขาเป็นคำทับศัพท์ JavaScript ของอัลกอริทึมหลัก:

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)