คุณอาจรู้จัก von Koch ซึ่งเป็นนักคณิตศาสตร์จากเกล็ดหิมะชื่อดังของเขา อย่างไรก็ตามเขามีปัญหาด้านวิทยาศาสตร์คอมพิวเตอร์ที่น่าสนใจมากกว่าเดิม ที่จริงเรามาดูการคาดเดานี้:

ให้ต้นไม้ที่มีnโหนด (ดังนั้นn-1ขอบ) หาวิธีที่จะระบุโหนดจาก1ไปnและตามขอบจาก1ไปn-1ในลักษณะที่แต่ละขอบแตกต่างของตัวเลขโหนดของมันเท่ากับk kการคาดเดาคือสิ่งนี้เป็นไปได้เสมอ

นี่คือตัวอย่างเพื่อให้ชัดเจนอย่างสมบูรณ์:

งานของคุณ

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

ตัวอย่างเช่นนี่คืออินพุตสำหรับต้นไม้ในภาพ:

[a,b,c,d,e,f,g]
d -> a
a -> b
a -> g
b -> c
b -> e
e -> f

รหัสของคุณจะต้องส่งคืนต้นไม้ที่มีโหนดและขอบเลข คุณสามารถส่งคืนเอาต์พุตกราฟิกเพิ่มเติม แต่ฉันจะให้ผลลัพธ์ประเภทนี้สำหรับกรณีทดสอบ:

[a7,b3,c6,d1,e5,f4,g2]
d -> a 6
a -> b 4
a -> g 5
b -> c 3
b -> e 2
e -> f 1

กรณีทดสอบ

[a,b,c,d,e,f,g]             [a7,b3,c6,d1,e5,f4,g2]
d -> a                      d -> a 6
a -> b                      a -> b 4
a -> g             =>       a -> g 5
b -> c                      b -> c 3
b -> e                      b -> e 2
e -> f                      e -> f 1


[a,b,c,d]                   [a4,b1,c3,d2]
a -> b                      a -> b 3
b -> c            =>        b -> c 2
b -> d                      b -> d 1


[a,b,c,d,e]                [a2,b3,c1,d4,e5]
a -> b                      a -> b 1
b -> c                      b -> c 2
c -> d             =>       c -> d 3
c -> e                      c -> e 4

นี่คือcode-golfนี่เป็นคำตอบที่สั้นที่สุดในหน่วยไบต์!

หมายเหตุ: นี่ดีกว่าการคาดคะเน Ringel-Kotzigซึ่งระบุว่าต้นไม้ทุกต้นมีการติดฉลากที่สง่างาม เนื่องจากในการคาดคะเน Koch มันเป็นไปไม่ได้ที่จะข้ามจำนวนเต็มสำหรับการติดฉลากที่ตรงกันข้ามกับการติดฉลากที่สง่างามในการคาดคะเน Ringel-Kotzig การติดฉลากที่สง่างามได้รับการถามก่อนที่นี่

เยลลี่ 30 ไบต์

JŒ!³,$€
ǵy⁴VIAµ€Q⁼$€TðḢịø³JŒ!

ลองออนไลน์! (ใช้GṄ³çGเป็นส่วนท้ายเพื่อทำให้เอาต์พุตสวยขึ้น)

อินพุตคล้ายกับตัวอย่างเช่นabcdefและ[d,a],[a,b],[a,g],[b,c],[b,e],[e,f]

ส่งออกรายการเช่นa,b,c,d,e,fในลำดับ

หมายเหตุ: โปรแกรมของฉันสร้างค่าที่แตกต่างจากกรณีทดสอบเนื่องจากมีความเป็นไปได้หลายอย่างที่ใช้ได้ทั้งหมด

คำอธิบาย

JŒ!³,$€                - helper function, generates all possible numberings, input is e.g. 'abcd'
J                      - range(len(input)). e.g. [1,2,3,4]
 Œ!                    - all permutations of the range.
   ³,$                 - pair the input with ... 
      €                - each permutation. Sample element e.g. ['abcd',[3,1,2,4]]

ǵy⁴VIAµ€Q⁼$€TðḢịø³JŒ! - main dyadic link, input is e.g. 'abcd' and '[a,b],[b,c],[b,d]'
 µy                    - use a numbering as an element-wise mapping e.g. 'abcd'->[3,1,2,4]
   ⁴                   - apply this to the list of edges. e.g. '[3,1],[1,2],[1,4]'
    V                  - turn this into an internal list.
     IAµ€              - find absolute difference on each edge
         Q⁼            - Is this invariant under deduplication? Returns 1 if the numbering is valid; 0 otherwise.
Ç          $€          - apply this to all possible numberings
             Tð        - return the indices of all valid numberings
               Ḣ       - choose the first one and
                ị      - get the element corresponding to its index in 
                 ø³JŒ! - all possible numberings 

บันทึก 1 ไบต์ด้วยการแสดงวิธีแก้ปัญหาที่เป็นไปได้ทั้งหมด:

JŒ!³,$€
ǵy⁴VIAµ€Q⁼$€Tðịø³JŒ!

ลองออนไลน์! (ใช้GṄ³çG⁷³Gเป็นส่วนท้ายเพื่อทำให้เอาต์พุตสวยขึ้น)

ใช้ตัวแปลงเพื่อคัดลอก - วางกรณีทดสอบลงในรายการอินพุต

Ruby, 108 ไบต์

ฟังก์ชั่น lamba ยอมรับอาร์เรย์ของอาร์เรย์ 2 องค์ประกอบที่มีขอบ (โดยที่แต่ละขอบแสดงเป็นคู่ของตัวเลขที่สอดคล้องกับบันทึกที่เกี่ยวข้อง)

->a{[*1..1+n=a.size].permutation.map{|i|k=a.map{|j|(i[j[0]-1]-i[j[1]-1]).abs}
(k&k).size==n&&(return[i,k])}}

Ungolfed ในโปรแกรมทดสอบ

f=->a{                                    #Accept an array of n tuples (where n is the number of EDGES in this case)
  [*1..1+n=a.size].permutation.map{|i|    #Generate a range 1..n+1 to label the nodes, convert to array, make an array of all permutations and iterate through it.
    k=a.map{|j|(i[j[0]-1]-i[j[1]-1]).abs} #Iterate through a, build an array k of differences between nodes per current permutation, as a trial edge labelling.
    (k&k).size==n&&(return[i,k])          #Intersect k with itself to remove duplicates. If all elements are unique the size will still equal n so
  }                                       #return a 2 element array [list of nodes, list of edges]
}

p f[[[4,1],[1,2],[1,7],[2,3],[2,5],[5,6]]]

p f[[[1,2],[2,3],[2,4]]]

p f[[[1,2],[2,3],[3,4],[2,5]]]

เอาท์พุต

ผลลัพธ์เป็นอาร์เรย์องค์ประกอบ 2 ซึ่งประกอบด้วย:

การกำหนดหมายเลขโหนดใหม่

การกำหนดหมายเลขขอบ

ตัวอย่างเช่นขอบแรกของตัวอย่างแรก[4,1]อยู่ระหว่างโหนด 6 และ 1 ภายใต้หมายเลขโหนดใหม่ดังนั้นจึงเป็นขอบ 6-1 = 5

[[1, 5, 2, 6, 3, 4, 7], [5, 4, 6, 3, 2, 1]]
[[1, 4, 2, 3], [3, 2, 1]]
[[1, 5, 3, 4, 2], [4, 2, 1, 3]]

ในความเป็นจริงมีหลาย solutons สำหรับแต่ละกรณีทดสอบ returnหยุดฟังก์ชั่นครั้งแรกที่พบ