Bạn có thể biết nhà toán học von Koch bởi bông tuyết nổi tiếng của mình. Tuy nhiên, anh ta có nhiều vấn đề khoa học máy tính thú vị hơn. Thật vậy, chúng ta hãy xem phỏng đoán này:

Cho một cây với ncác nút (do đó n-1các cạnh). Tìm cách liệt kê các nút từ 1đến nvà, theo đó, các cạnh từ 1đến n-1theo cách như vậy, với mỗi cạnh, ksự khác biệt của số nút của nó bằng k. Phỏng đoán là điều này luôn luôn có thể.

Đây là một ví dụ để làm cho nó hoàn toàn rõ ràng:

NHIỆM VỤ CỦA BẠN

Mã của bạn sẽ lấy đầu vào là một cây, bạn có thể lấy định dạng bạn muốn nhưng đối với các trường hợp thử nghiệm tôi sẽ cung cấp cho cây theo các cung và danh sách các nút của chúng.

Ví dụ, đây là đầu vào cho cây trong hình:

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

Mã của bạn phải trả về cây với các nút và các cạnh được đánh số. Bạn có thể trả về một đầu ra đồ họa nhiều hơn nhưng tôi sẽ cung cấp loại đầu ra này cho các trường hợp thử nghiệm:

[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

TRƯỜNG HỢP KIỂM TRA

[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

Đây là code-golf đây là câu trả lời ngắn nhất trong byte win!

Lưu ý: Điều này mạnh hơn phỏng đoán Ringel-Kotzig , trong đó tuyên bố mỗi cây đều có nhãn hiệu duyên dáng. Vì trong phỏng đoán của Koch, không thể bỏ qua các số nguyên cho việc ghi nhãn trái với ghi nhãn duyên dáng trong phỏng đoán Ringel-Kotzig. Ghi nhãn duyên dáng đã được yêu cầu trước đây ở đây .

Thạch , 30 byte

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

Hãy thử trực tuyến! (Sử dụng GṄ³çGnhư chân trang để làm cho đầu ra đẹp hơn.)

Các đầu vào tương tự như ví dụ, ví dụ abcdefvà[d,a],[a,b],[a,g],[b,c],[b,e],[e,f]

Xuất ra danh sách, ví dụ a,b,c,d,e,ftheo thứ tự.

Lưu ý: Chương trình của tôi tạo ra các giá trị khác với các trường hợp thử nghiệm vì có một số khả năng hoàn toàn hợp lệ.

Giải trình

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 

Lưu 1 byte bằng cách hiển thị tất cả các giải pháp có thể:

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

Hãy thử trực tuyến! (Sử dụng GṄ³çG⁷³Gnhư chân trang để làm cho đầu ra đẹp hơn)

Sử dụng trình chuyển đổi để sao chép-dán trường hợp kiểm tra vào danh sách đầu vào.

Ruby, 108 byte

Hàm lamba, chấp nhận một mảng các mảng 2 phần tử chứa các cạnh (trong đó mỗi cạnh được thể hiện dưới dạng một cặp số tương ứng với các ghi chú có liên quan.)

->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 trong chương trình thử nghiệm

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

Đầu ra

đầu ra là một mảng 2 phần tử, chứa:

đánh số nút mới

đánh số cạnh.

Ví dụ, cạnh đầu tiên của ví dụ đầu tiên [4,1]là giữa các nút 6 và 1 dưới cách đánh số nút mới và do đó là cạnh 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]]

Trong thực tế, có nhiều solutons cho mỗi trường hợp thử nghiệm. các returndừng chức năng lần đầu tiên được tìm thấy.