Anda mungkin mengenal ahli matematika von Koch dengan kepingan saljunya yang terkenal. Namun ia memiliki masalah ilmu komputer yang lebih menarik. Memang, mari kita lihat dugaan ini:

Diberikan pohon dengan nsimpul (dengan demikian n-1ujung). Temukan cara untuk menghitung node dari 1ke ndan, sesuai, tepi dari 1ke n-1cara seperti itu, bahwa untuk setiap tepi kperbedaan angka simpul yang sama dengan k. Dugaannya adalah bahwa ini selalu mungkin.

Berikut ini contoh untuk membuatnya sangat jelas:

TUGAS ANDA

Kode Anda akan mengambil sebagai input pohon, Anda dapat mengambil format yang Anda inginkan tetapi untuk kasus uji saya akan menyediakan pohon dengan busur mereka dan daftar node mereka.

Misalnya ini adalah input untuk pohon dalam gambar:

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

Kode Anda harus mengembalikan pohon dengan nomor node dan tepi. Anda dapat mengembalikan output yang lebih grafis tetapi saya akan memberikan output semacam ini untuk kasus uji:

[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

KASUS UJI

[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

Ini adalah kode-golf ini jawaban terpendek dalam byte yang menang!

Catatan: Ini lebih kuat dari dugaan Ringel-Kotzig , yang menyatakan setiap pohon memiliki label anggun. Karena dalam dugaan Koch tidak mungkin untuk melewatkan bilangan bulat untuk pelabelan yang bertentangan dengan pelabelan anggun dalam dugaan Ringel-Kotzig. Pelabelan yang anggun telah ditanyakan sebelumnya di sini .

Jelly , 30 byte

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

Cobalah online! (Gunakan GṄ³çGsebagai footer untuk membuat output lebih cantik.)

Input mirip dengan contoh, misalnya abcdefdan[d,a],[a,b],[a,g],[b,c],[b,e],[e,f]

Keluarkan daftar misalnya a,b,c,d,e,fdalam urutan.

Catatan: Program saya menghasilkan nilai yang berbeda dari kasus uji karena ada beberapa kemungkinan yang semuanya valid.

Penjelasan

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 

Hemat 1 byte dengan menunjukkan semua solusi yang mungkin:

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

Cobalah online! (Gunakan GṄ³çG⁷³Gsebagai footer untuk membuat output lebih cantik)

Gunakan konverter untuk menyalin-tempel test case ke dalam daftar input.

Ruby, 108 byte

fungsi lamba, menerima larik array 2-elemen yang mengandung tepi (di mana setiap tepi dinyatakan sebagai pasangan angka yang sesuai dengan catatan yang relevan.)

->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])}}

Tidak digabungkan dalam program uji

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]]]

Keluaran

output adalah array 2 elemen, mengandung:

penomoran simpul baru

penomoran tepi.

Misalnya tepi pertama dari contoh pertama [4,1]adalah antara node 6 dan 1 di bawah penomoran simpul baru dan karenanya edge 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]]

Sebenarnya ada beberapa soluton untuk setiap test case. yang returnberhenti fungsi sekali yang pertama ditemukan.