Escriba un programa o función que incluya una lista no vacía de desigualdades matemáticas que utilizan el operador menor que ( <). Cada línea en la lista tendrá la forma

[variable] < [variable]

donde a [variable]puede ser cualquier cadena no vacía de caracteres az minúsculas. Como en matemática y programación normales, las variables con el mismo nombre son idénticas.

Si se puede asignar un entero positivo a cada variable de modo que se satisfagan todas las desigualdades, imprima o devuelva una lista de las variables con dicha asignación. Cada línea en esta lista debe tener la forma

[variable] = [positive integer]

y todas las variables deben ocurrir exactamente una vez en cualquier orden.

Tenga en cuenta que puede haber muchas posibles soluciones enteras positivas para el conjunto de desigualdades. Cualquiera de ellos es salida válida.

Si no hay soluciones para las desigualdades, entonces no genere nada o genere un valor falso (depende de usted).

El código más corto en bytes gana.

Ejemplos

Si la entrada fuera

mouse < cat
mouse < dog

entonces todos estos serían resultados válidos:

mouse = 1
cat = 2
dog = 2

mouse = 37
cat = 194
dog = 204

mouse = 2
cat = 2000000004
dog = 3

Si la entrada fuera

rickon < bran
bran < arya
arya < sansa
sansa < robb
robb < rickon

entonces no es posible la asignación porque se reduce a rickon < rickon, por lo que no hay salida o una salida falsa.

Más ejemplos con soluciones:

x < y

x = 90
y = 91

---

p < q
p < q

p = 1
q = 2

---

q < p
q < p

p = 2
q = 1

---

abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyzz

abcdefghijklmnopqrstuvwxyz = 123456789
abcdefghijklmnopqrstuvwxyzz = 1234567890

---

pot < spot
pot < spot
pot < spots

pot = 5
spot = 7
spots = 6

---

d < a
d < b
d < c
d < e

d = 1
a = 4
b = 4
c = 5
e = 4

---

aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa

aaaa = 4
aa = 2
aaaaa = 5
a = 1
aaa = 3

---

frog < toad
frog < toaster
toad < llama
llama < hippo
raccoon < science
science < toast
toaster < toad
tuna < salmon
hippo < science
toasted < toast

raccoon = 1
frog = 2
toaster = 3
toasted = 4
toad = 5
llama = 6
hippo = 7
science = 8
toast = 9
tuna = 10
salmon = 11

Más ejemplos sin soluciones: (separados por líneas vacías)

z < z

ps < ps
ps < ps

q < p
p < q

p < q
q < p

a < b
b < c
c < a

d < a
d < b
d < c
d < d

abcdefghijklmnopqrstuvwxyz < abcdefghijklmnopqrstuvwxyz

bolero < minuet
minuet < bolero

aa < aaaaa
a < aa
aaa < aaaa
aa < aaaa
aaaaa < aaaa
a < aaa
aaaa < aaaaa
aaa < aaaaa
a < aaaaa

g < c
a < g
b < a
c < a

g < b
a < g
b < a
c < a

g < b
a < g
b < a
c < b

g < c
a < g
b < a
c < b

geobits < geoborts
geobrits < geoborts
geology < geobits
geoborts < geology

Pyth, 39 bytes

V>1f.A<MxMLTN.pS{s=Nm%2cd).zVNjd[H\==hZ

Pruébelo en línea: demostración

Fuerzas brutas a través de todas las permutaciones posibles (e interpretarlas como clasificaciones), verificar si coinciden con las desigualdades y asignarles los valores 1, 2, ...., n.

Explicación

f.A<MxMLTN.pS{s=Nm%2cd).z  
                 m     .z  map each input line d to:
                    cd)       split d by spaces
                  %2          and remove the second element
               =N          save this list of pairs to N
              s            combine these pairs to a big list of variable names
             {             set (remove duplicates)
          .pS              generate all permutations
f                          filter for permutations T, which satisfy:
     xMLTN                    replace each variable in N by their index in T
 .A<M                         check if each pair is ascending

V>1...VNjd[H\==hZ          implicit: Z = 0
 >1                        remove all but the last filtered permutation (if any)
V                          for each permutation N in ^ (runs zero times or once):
      VN                      for each variable H in N:
          [                      generate a list containing:
           H                        H
            \=                      "="
              =hZ                   Z incremented by 1 (and update Z)
        jd                       join this list by spaces and print

CJam ( 53 52 49 bytes)

qS-N/'<f/:A:|e!{A{1$1$&=!},!*},:ee{()" = "\N}f%1<

Demostración en línea

Esta fuerza bruta fuerza todas las permutaciones de los distintos tokens, filtrando las asignaciones de los números. 0 a los n-1que obedecen todas las restricciones, y luego las formatea, incrementando los números, y presenta la primera. Es seguro encontrar una solución si hay una, porque es esencialmente un tipo topológico.

Gracias a Reto Koradi por 3 personajes y Martin Büttner por 1.

Mathematica, 83 bytes

Quiet@Check[Equal@@@FindInstance[Join[#,#>0&/@(v=Sequence@@@#)],v,Integers][[1]],]&

Toma información como una lista de desigualdades. O genera una lista de tareas o Nullsi es imposible.