In der Graphentheorie ist ein Prüfer-Code eine eindeutige Folge von ganzen Zahlen, die einen bestimmten Baum bezeichnen.

Sie finden den Prüfer-Code eines Baumes mit dem folgenden Algorithmus aus Wikipedia:

Betrachten Sie einen beschrifteten Baum T mit Eckpunkten {1, 2, ..., n}. Entfernen Sie in Schritt i das Blatt mit der kleinsten Beschriftung und setzen Sie das i- te Element der Prüfer-Sequenz als Beschriftung des Nachbarn dieses Blattes.

(Da es sich um ein Blatt handelt, hat es nur einen Nachbarn).

Sie sollten die Iteration stoppen, wenn nur noch zwei Scheitelpunkte im Diagramm verbleiben.

Aufgabe

Bei einem beschrifteten Baum als Eingabe wird der Prüfer-Code ausgegeben. Sie können auf jede vernünftige Weise Eingaben machen. B. eine Adjazenzmatrix oder eine in Ihren Sprachen integrierte Diagrammdarstellung. ( Sie dürfen keine Eingabe als Prüfer-Code vornehmen ).

Dies ist Code-Golf, daher sollten Sie versuchen, die Bytes in Ihrer Quelle zu minimieren.

Testfälle

Hier sind einige Eingaben in ASCII mit ihren Ausgängen unten. Sie müssen solche ASCII-Eingaben nicht unterstützen.

    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}

Mathematica, 34 Bytes

<<Combinatorica`
LabeledTreeToCode

Jemand musste es tun ...

Nach dem Laden des CombinatoricaPakets LabeledTreeToCodeerwartet die Funktion eine Baumeingabe als ungerichteten Graphen mit explizit aufgelisteten Kanten und Scheitelpunkten. Zum Beispiel könnte die Eingabe im zweiten Testfall sein 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 Bytes

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)

Nimmt die Eingabe als Adjazenzmatrix auf. Erstes Beispiel:

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

Gelee , 31 Bytes

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

Eine monadische Verknüpfung, die eine Liste von Knotenpaaren (die die Kanten definiert) in beliebiger Reihenfolge (und jeweils in beliebiger Ausrichtung) erstellt und den Prüfer-Code als Liste zurückgibt.

Probieren Sie es online aus!

Wie?

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 Bytes

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

Probieren Sie es online aus!

Erläuterung

[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 Bytes

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

Erfordert, dass die Eingabe eine Hash-Map ist, mit "blattartigen" Beschriftungen als Schlüssel und "wurzelartigen" Beschriftungen als Werten. Beispielsweise:

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

Bei jeder Iteration wird der kleinste Schlüssel gefunden, auf den kein anderer Knoten verweist, er wird dem Ergebnis rhinzugefügt und der Knoten aus der Diagrammdefinition entfernt G. if-letgeht zu else case wenn Gleer ist, als firstreturn nil. Auch das letzte Element muss gelöscht werden.

Python 2 , 91 Bytes

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

Probieren Sie es online aus!

Basierend auf der Lösung von L3viathan . Nimmt ein Wörterbuch mit Sätzen, die Adjazenzlisten darstellen.