Schreiben Sie ein Programm oder eine Funktion, die eine nicht leere Liste mathematischer Ungleichungen enthält , die den Operator less than ( <) verwenden. Jede Zeile in der Liste hat das Formular

[variable] < [variable]

Dabei [variable]kann a eine beliebige nicht leere Zeichenfolge mit az-Kleinbuchstaben sein. Wie in der normalen Mathematik und Programmierung sind gleichnamige Variablen identisch.

Wenn jeder Variablen eine positive Ganzzahl zugewiesen werden kann, sodass alle Ungleichungen erfüllt sind, können Sie eine Liste der Variablen mit einer solchen Zuordnung drucken oder zurückgeben. Jede Zeile in dieser Liste sollte das Formular haben

[variable] = [positive integer]

und alle Variablen müssen in beliebiger Reihenfolge genau einmal vorkommen.

Beachten Sie, dass es viele mögliche positive Ganzzahllösungen für die Menge der Ungleichungen geben kann. Jeder von ihnen ist eine gültige Ausgabe.

Wenn es keine Lösungen für die Ungleichungen gibt, geben Sie entweder nichts oder einen falschen Wert aus (es liegt an Ihnen).

Der kürzeste Code in Bytes gewinnt.

Beispiele

Wenn die Eingabe wäre

mouse < cat
mouse < dog

dann wären alle diese Ausgaben gültig:

mouse = 1
cat = 2
dog = 2

mouse = 37
cat = 194
dog = 204

mouse = 2
cat = 2000000004
dog = 3

Wenn die Eingabe wäre

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

dann ist keine Zuordnung möglich, da es sich um rickon < rickoneine auf ergibt, sodass entweder keine oder eine falsche Ausgabe erfolgt.

Weitere Beispiele mit Lösungen:

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

Weitere Beispiele ohne Lösungen: (durch Leerzeilen getrennt)

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

Probieren Sie es online aus: Demonstration

Durchforsten Sie alle möglichen Permutationen (und interpretieren Sie sie als Sortierungen), überprüfen Sie, ob sie mit den Ungleichungen übereinstimmen, und weisen Sie ihnen die Werte zu 1, 2, ...., n.

Erläuterung

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<

Online-Demo

Diese Methode erzwingt alle Permutationen der unterschiedlichen Token, filtert nach den Zuweisungen der Nummern 0, n-1denen alle Einschränkungen entsprechen, formatiert sie dann, inkrementiert die Nummern und präsentiert die erste. Dies wird mit Sicherheit eine Lösung finden, wenn es eine gibt, da es sich im Wesentlichen um eine topologische Art handelt.

Danke an Reto Koradi für 3 Zeichen und Martin Büttner für 1 Zeichen .

Mathematica, 83 Bytes

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

Nimmt Eingaben als Liste von Ungleichungen auf. Gibt entweder eine Liste von Zuordnungen aus oder Nullist dies nicht möglich.