Trong đồ thị lý thuyết một đang Prufer là một chuỗi duy nhất của số nguyên biểu thị một cây cụ thể.

Bạn có thể tìm thấy mã Prüfer của cây với thuật toán sau được lấy từ Wikipedia:

Hãy xem xét một cây có nhãn T với các đỉnh {1, 2, ..., n}. Ở bước i , loại bỏ chiếc lá có nhãn nhỏ nhất và đặt phần tử thứ i của chuỗi Prüfer là nhãn của hàng xóm của chiếc lá này.

(Lưu ý rằng vì nó là một chiếc lá nên nó sẽ chỉ có một hàng xóm).

Bạn nên dừng việc lặp lại khi chỉ còn hai đỉnh trong biểu đồ.

Bài tập

Cho một cây có nhãn là đầu ra đầu ra mã Prüfer của nó. Bạn có thể nhận đầu vào theo bất kỳ cách hợp lý. Chẳng hạn như ma trận kề hoặc biểu diễn biểu đồ dựng sẵn ngôn ngữ của bạn. ( Bạn không thể lấy đầu vào làm mã Prüfer ).

Đây là môn đánh gôn, vì vậy bạn nên cố gắng giảm thiểu các byte trong nguồn của mình.

Các trường hợp thử nghiệm

Dưới đây là một số đầu vào trong ASCII với đầu ra của chúng bên dưới. Bạn không cần phải hỗ trợ đầu vào ASCII như thế này.

    3
    |
1---2---4---6
    |
    5

{2,2,2,4}

1---4---3
    |
5---2---6---7
|
8

{4,4,2,6,2,5}

5---1---4   6
    |       |
    2---7---3

{1,1,2,7,3}

Toán học, 34 byte

<<Combinatorica`
LabeledTreeToCode

Một ai đó đã phải làm chuyện đó....

Sau khi tải Combinatoricagói, hàm LabeledTreeToCodedự kiến ​​đầu vào cây dưới dạng biểu đồ không bị chặn với các cạnh và đỉnh được liệt kê rõ ràng; ví dụ, đầu vào trong trường hợp thử nghiệm thứ hai có thể là Graph[{{{1, 4}}, {{4, 3}}, {{4, 2}}, {{2, 5}}, {{2, 6}}, {{6, 7}}, {{5, 8}}}, {1, 2, 3, 4, 5, 6, 7, 8}].

Python 3, 136 131 127 byte

def f(t):
 while len(t)>2:
  m=min(x for x in t if len(t[x])<2);yield t[m][0];del t[m]
  for x in t:m in t[x]and t[x].remove(m)

Đưa đầu vào như một ma trận kề. Ví dụ đầu tiên:

>>> [*f({1:[2],2:[1,3,4,5],3:[2],4:[2,6],5:[2],6:[4]})]
[2, 2, 2, 4]

Thạch , 31 byte

FĠLÞḢḢ
0ịµÇHĊṙ@µÇCịṪ,
WÇÐĿḢ€ṖṖḊ

Một liên kết đơn sẽ lấy danh sách các cặp nút (xác định các cạnh) theo bất kỳ thứ tự nào (và mỗi theo bất kỳ hướng nào) và trả về Mã Prüfer dưới dạng danh sách.

Hãy thử trực tuyến!

Làm sao?

FĠLÞḢḢ - Link 1, find leaf location: list of edges (node pairs)
F      - flatten
 Ġ     - group indices by value (sorted smallest to largest by value)
  LÞ   - sort by length (stable sort, so equal lengths remain in prior order)
    ḢḢ - head head (get the first of the first group. If there are leaves this yields
       -   the index of the smallest leaf in the flattened version of the list of edges)

0ịµÇHĊṙ@µÇCịṪ, - Link 2, separate smallest leaf: list with last item a list of edges
0ị             - item at index zero - the list of edges
  µ            - monadic chain separation (call that g)
   Ç           - call last link (1) as a monad (index of smallest leaf if flattened)
    H          - halve
     Ċ         - ceiling (round up)
      ṙ@       - rotate g left by that amount (places the edge to remove at the right)
        µ      - monadic chain separation (call that h)
         Ç     - call last link (1) as a monad (again)
          C    - complement (1-x)
            Ṫ  - tail h (removes and yields the edge)
           ị   - index into, 1-based and modular (gets the other node of the edge)
             , - pair with the modified h
               -    (i.e. [otherNode, restOfTree], ready for the next iteration)

WÇÐĿḢ€ṖṖḊ - Main link: list of edges (node pairs)
W         - wrap in a list (this is so the first iteration works)
  ÐĿ      - loop and collect intermediate results until no more change:
 Ç        -   call last link (2) as a monad
    Ḣ€    - head €ach (get the otherNodes, although the original tree is also collected)
      ṖṖ  - discard the two last results (they are excess to requirements)
        Ḋ - discard the first result (the tree, leaving just the Prüfer Code)

05AB1E , 29 byte

[Dg#ÐD˜{γé¬`U\X.å©Ï`XK`ˆ®_Ï]¯

Hãy thử trực tuyến!

Giải trình

[Dg#                           # loop until only 1 link (2 vertices) remain
    ÐD                         # quadruple the current list of links
      ˜{                       # flatten and sort values
        γé                     # group by value and order by length of runs
          ¬`U                  # store the smallest leaf in X
             \X                # discard the sorted list and push X
               .å©             # check each link in the list if X is in that link
                  Ï`           # keep only that link
                    XK`ˆ       # add the value that isn't X to the global list
                        ®_Ï    # remove the handled link from the list of links
                           ]   # end loop
                            ¯  # output global list

Clojure, 111 byte

#(loop[r[]G %](if-let[i(first(sort(remove(set(vals G))(keys G))))](recur(conj r(G i))(dissoc G i))(butlast r)))

Yêu cầu đầu vào phải là bản đồ băm, có nhãn "giống như chiếc lá" làm khóa và nhãn "giống như gốc" làm giá trị. Ví dụ:

{1 2, 3 2, 5 2, 4 2, 6 4}
{1 4, 3 4, 4 2, 8 5, 5 2, 7 6, 6 2}

Trên mỗi lần lặp, nó tìm thấy khóa nhỏ nhất không được tham chiếu bởi bất kỳ nút nào khác, thêm nó vào kết quả rvà xóa nút khỏi định nghĩa biểu đồ G. if-letđi đến trường hợp khác khi Gtrống, như firsttrả về nil. Ngoài ra yếu tố cuối cùng phải được loại bỏ.

Python 2 , 91 byte

d=input()
while len(d)>2:m=min(d,key=lambda k:len(d[k]));n,=d[m];del d[m];d[n]-={m};print n

Hãy thử trực tuyến!

Dựa trên giải pháp của L3viathan . Lấy một từ điển các bộ đại diện cho danh sách kề.