Es posible que conozca al matemático von Koch por su famoso copo de nieve. Sin embargo, tiene problemas de ciencias de la computación más interesantes bajo la manga. De hecho, echemos un vistazo a esta conjetura:

Dado un árbol con nnodos (por lo tanto, n-1bordes). Encuentre una manera de enumerar los nodos de 1a ny, en consecuencia, los bordes de 1a n-1de tal manera que para cada borde kla diferencia de sus números de nodo sea igual a k. La conjetura es que esto siempre es posible.

Aquí hay un ejemplo para dejarlo perfectamente claro:

TU TAREA

Su código tomará como entrada un árbol, puede tomar el formato que desee, pero para los casos de prueba, proporcionaré el árbol por sus arcos y la lista de sus nodos.

Por ejemplo, esta es la entrada para el árbol en la imagen:

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

Su código debe devolver el árbol con nodos y bordes numerados. Puede devolver una salida más gráfica, pero proporcionaré este tipo de salida para los casos de prueba:

[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

CASOS DE PRUEBA

[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

Este es el código de golf, ¡ esta es la respuesta más corta en bytes!

Nota: Esto es más fuerte que la conjetura de Ringel-Kotzig , que establece que cada árbol tiene un etiquetado elegante. Dado que en la conjetura de Koch no es posible omitir números enteros para el etiquetado contrario al etiquetado elegante en la conjetura de Ringel-Kotzig. Se ha pedido un etiquetado elegante antes aquí .

Jalea , 30 bytes

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

Pruébalo en línea! (Use GṄ³çGcomo pie de página para hacer que la salida sea más bonita).

Entradas similares al ejemplo, por ejemplo, abcdefy[d,a],[a,b],[a,g],[b,c],[b,e],[e,f]

Emite la lista, por ejemplo, a,b,c,d,e,fen orden.

Nota: Mi programa produce valores diferentes a los casos de prueba ya que hay varias posibilidades que son todas válidas.

Explicación

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 

Ahorre 1 byte mostrando todas las soluciones posibles:

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

Pruébalo en línea! (Úselo GṄ³çG⁷³Gcomo pie de página para que la salida sea más bonita)

Use el convertidor para copiar y pegar el caso de prueba en una lista de entrada.

Ruby, 108 bytes

función lamba, acepta una matriz de matrices de 2 elementos que contienen los bordes (donde cada borde se expresa como un par de números correspondientes a las notas relevantes).

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

Sin golf en el programa de prueba

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

Salida

La salida es una matriz de 2 elementos que contiene:

la nueva numeración de nodos

La numeración del borde.

Por ejemplo, el primer borde del primer ejemplo [4,1]está entre los nodos 6 y 1 bajo la nueva numeración de nodos y, por lo tanto, es el borde 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]]

De hecho, hay múltiples soluciones para cada caso de prueba. la returndetiene la función una vez que se encuentra la primera.