_{Diese Herausforderung besteht darin, die Stimmung unseres Mods Alex A. zu heben , der normalerweise Unrecht hat .}

Angenommen, Sie haben einen Freund namens Alex, der Hilfe bei der grundlegenden Logik und Mathematik benötigt, insbesondere bei der mathematischen Äquivalenz .

Er gibt Ihnen eine Liste von Gleichungen in der Form, [variable] = [variable]in der a [variable]immer ein einzelner Großbuchstabe von A bis Z ist (kein Kleinbuchstabe, keine Zahl oder etwas anderes). Es gibt eine Gleichung pro Zeile in der Liste mit Ausnahme einer einzelnen Zeile, die nur besagt therefore.

Alle Gleichungen über dem thereforesind Prämissen , Tatsachen, von denen angenommen wird, dass sie wahr sind. Alle nachstehenden Gleichungen thereforesind unbestätigte Aussagen, Tatsachen, die Alex aus den Prämissen abzuleiten versucht, und sie können wahr sein oder auch nicht.

Zum Beispiel ist in dieser Gleichungsliste der einzige Schlusssatz A = Czufällig wahr:

A = B
B = C
therefore
A = C

Es ist Ihre Aufgabe, Alex zu sagen, ob alle seine Vorschläge logisch aus den gegebenen Voraussetzungen folgen. Das heißt, Sie müssen Alex sagen, ob er in seinen Schlussfolgerungen falsch oder richtig ist.

Schreiben Sie ein Programm / eine Funktion, die eine Folge einer Liste von Gleichungen wie beschrieben aufnimmt und ausgibt / zurückgibt

Alex is right

wenn alle Schlussfolgerungen logisch aus den Räumlichkeiten folgen und ansonsten ausgegeben werden

Alex is wrong

wenn eine Schlussfolgerung nicht logisch aus den Räumlichkeiten folgt.

Der kürzeste Code in Bytes gewinnt.

Achten Sie auf folgende Fälle:

• Variable ist immer gleich. z.B

  B = A
  therefore
  A = A
  X = X
  

  Ergebnisse in Alex is right.

• Variablen mit unbekannten Beziehungen können nicht als gleich angenommen werden. z.B

  P = Q
  therefore
  E = R
  

  Ergebnisse in Alex is wrong.

• Wenn es nach dem keine Gleichungen mehr gibt, sind thereforedie Schlussfolgerungen nicht korrekt . z.B

  D = C
  therefore

  und

  therefore

  beide ergeben Alex is right.

• Wenn es keine Gleichungen thereforegibt, kann nur auf die Selbstgleichheit geschlossen werden. z.B

  therefore
  R = R
  

  Ergebnisse in Alex is right, aber

  therefore
  R = W
  

  Ergebnisse in Alex is wrong.

Mehr Beispiele

Alex ist in falschen Fällen: (durch Leerzeilen getrennt)

A = B
C = D
therefore
A = C

A = L
E = X
A = I
S = W
R = O
N = G
therefore
G = N
L = I
R = O
S = A
X = X
X = E

D = K
D = Q
L = P
O = L
M = O
therefore
K = L

A = B
therefore
B = C

Z = A
S = S
therefore
A = Z
A = A
S = A
A = S
Z = A
Z = A

K = L
K = X
therefore
X = P
L = X
L = P

therefore
A = B
B = C
A = C

therefore
A = A
B = B
C = C
D = D
E = E
F = F
G = G
H = H
I = I
J = J
K = K
T = I
L = L
M = M
N = N
O = O
P = P
Q = Q
R = R
S = S
T = T
U = U
V = V
W = W
X = X
Y = Y
Z = Z

A = B
B = C
C = D
D = E
E = F
F = G
G = H
H = I
I = J
J = K
K = L
L = M
M = N
N = O
O = P
P = O
Q = R
R = S
S = T
T = U
U = V
V = W
W = X
X = Y
Y = Z
therefore
A = Z

therefore
C = D
T = Y
A = Z

P = Q
therefore
E = R

therefore
R = W

Alex hat Recht:

H = J
therefore
J = H

K = L
K = X
therefore
L = X

C = B
B = A
therefore
A = B

K = L
K = X
K = P
therefore
L = X
L = P
X = P

A = Y
Y = Q
Q = O
therefore
O = Y
O = A

C = C
therefore
C = C

A = B
B = A
therefore
A = B
B = A

A = B
B = C
C = D
therefore
A = A
A = B
A = C
A = D
B = A
B = B
B = C
B = D
C = A
C = B
C = C
C = D
D = A
D = B
D = C
D = D

therefore
A = A
B = B
C = C
D = D
E = E
F = F
G = G
H = H
I = I
J = J
K = K
L = L
M = M
N = N
O = O
P = P
Q = Q
R = R
S = S
T = T
U = U
V = V
W = W
X = X
Y = Y
Z = Z

D = I
F = H
J = M
therefore
M = J
D = I
H = F

A = B
B = C
C = D
D = E
E = F
F = G
G = H
H = I
I = J
J = K
K = L
L = M
M = N
N = O
O = P
P = Q
Q = R
R = S
S = T
T = U
U = V
V = W
W = X
X = Y
Y = Z
therefore
Z = A
F = R
G = I
W = L

A = B
B = C
therefore
A = C

B = A
therefore
A = A
X = X

P = P
C = G
M = C
therefore

D = C
therefore

therefore

therefore
R = R

CJam, 49

"Alex is "qN%S{f{)er}(_el-}h;{)#},"wrong""right"?

Inspiriert von der Ruby-Lösung von Histocrat. Probieren Sie es online
3 Bytes ausgelöscht dank jimmy23013 :)

Erläuterung:

Für jede Prämisse ersetzt das Programm die erste Variable durch die zweite Variable im restlichen Text. Anschließend wird geprüft, ob Schlussfolgerungen mit unterschiedlichen Variablen vorliegen.

"Alex is "    first push the part we know
qN%           read the input and split into lines
S             push a space (initial no-op replacement string, see below)
{…}h          do-while
  f{…}        for each line and the replacement string
    )         take out the last character
    er        replace the remaining character(s) with that character
  (           afterwards, take out the first line
  _el         duplicate and convert to lowercase
  -           remove all the resulting characters from the line
               this removes all lowercase letters and non-letters
               "X = Y" becomes "XY" (new replacement string)
               and "therefore" becomes "" (ending the loop)
              this is the loop condition and is left on the stack every time
;             after the loop, pop the empty string (from "therefore")
{…},          filter the remaining (conclusion) lines using the condition block
  )           take out the last character
  #           find its index in the remaining string
               this is 0 (false) iff the first character is the same as the last
              afterwards, we have an array of lines with non-equal variables
"wrong"       push "wrong"
"right"       push "right"
?             choose "wrong" if the array was not empty, else choose "right"

Alte Version, 85

"Alex is "26,:A;{:i{{_A=_@-}g}%$~}:F;0q"= "-'t/Nf%~\{A\Ft:A;}/1>{F=}%-"right""wrong"?

Dies verwendet einen Union-Find-Algorithmus. Probieren Sie es online aus

Ruby, 80, 76 + 2 = 78

p0Führen Sie mit Befehlszeilenflags aus

gsub$1,$2%p=$`[/e/]while~/(.) = (?!\1)(.)/
$_="Alex is #{p ?:wrong: :right}"

Erläuterung:

Dies verwendet eine reine String-Manipulation. p0Liest die vollständige Eingabe als einzelne Zeichenfolge in die Variable $_. Dann vergleichen wir diese Zeichenfolge wiederholt mit dem regulären Ausdruck /(.) = (?!\1)(.)/, der alle Zeichenfolgen der Form "X = Y" findet, bei denen X und Y nicht der gleiche Buchstabe sind, und ordnet X $ 1 und Y $ 2 zu. Wenn eine solche Übereinstimmung gefunden wird, werden gsub$1,$2alle Instanzen von X durch Y in der Zeichenfolge ersetzt. Wir prüfen auch, ob diese Übereinstimmung vor oder nach dem "deshalb" mit aufgetreten ist

$`[/e/]

Wenn es danach passiert ist, ist es eine ungerechtfertigte Behauptung und Alex ist falsch. Wir verfolgen mithilfe von, ob solche Vorkommnisse aufgetreten sind p=. Die Verwendung von pals Tracking-Variable verhindert, dass die Schleife unterbrochen pwird, wenn sie nicht ein einziges Mal ausgeführt wird.

Ab diesem Beitrag ist die CJam-Lösung länger. Ein stolzer, zweifellos flüchtiger Moment.

Edit: Ja, schnell entthront. Um die Erklärung zu beenden, wird mit dem pFlag der Endwert von $_am Ende der Ausführung ausgegeben, sodass die letzte Zeile die Ausgabe ist.

CJam, 83 75 68 67 64 Bytes

Vielen Dank an Dennis für das Speichern von 1 Byte.

"Alex is "q_elN--N/:$La/~{)-},\{__m*{:&},::^|}5*-"wrong""right"?

Testsuite. Die Testfälle sind zu lang für einen Permalink. Kopieren Sie sie einfach aus der Frage. Beachten Sie, dass dies ziemlich langsam ist - im Online-Dolmetscher dauert es ein oder zwei Minuten. Sie können es viel schneller machen , indem 5*zu 2*in diesem Fall ist es fast sofort beenden wird und alle bis auf einen Testfall lösen.

Erläuterung

(Etwas veraltet.)

Die Idee ist, eine Art "Überflutung" möglicher Gleichheiten durchzuführen und dann alle Gleichheiten, die wir erhalten haben, aus der Abschlussliste zu entfernen. Es kann gezeigt werden, dass wir nicht mehr als 5 Schritte der Überflutungsfüllung benötigen, da diese einen Abstand (in der anfänglichen Ungleichungsgrafik) von 25 zurücklegen würden, aber der maximale Abstand 25 beträgt.25 = 32

"Alex is " e# Push the string.
q          e# Read the input.
_elN-      e# Make a copy, convert to lower case, remove linefeeds. This gives us a string
           e# with all the characters we don't want from the input.
-          e# Remove them from the input. This leaves two upper-case letters on each line
           e# and an empty line between premises and conclusions.
N/         e# Split into lines.
La/        e# Split around the empty line.
~          e# Dump both halves on the stack.
{)-},      e# Remove any "A = A"-type equalities from the conclusions.
\          e# Swap with the premises.
{          e# Extend the premises 5 times...
  _Wf%     e#   Duplicate the premises and reverse each one, because = is symmetric.
  |        e#   Set union with the original premises.
  __m*     e#   Make two copies and get an array of every possible pair of premises.
  {:&},    e#   Select those which have at least one character in common.
  ::^      e#   For each such pair, take the mutual set difference, i.e. those characters
           e#   that are in only one of the strings.
  |        e#   Set union with the original premises.
}5*
-          e# Remove all the equalities we've obtained from the conclusions. If all
           e# conclusions were valid, the result will now be a empty array, which is falsy.
!          e# Logical not.
"wrong""right"?
           e# Select "wrong" or "right", respectively.

R, 183 192 Bytes

Ich habe meine Antwort geändert, um eine Einschränkung zu beheben, auf die user2357112 hingewiesen hat. Es gibt immer noch eine äußerst geringe Wahrscheinlichkeit, Alex anzurufen, wenn er tatsächlich Recht hat (was anscheinend nicht sehr oft vorkommt, wenn ich den Kontext der Herausforderung verstehe :-). Ich hoffe, es wird ihm nichts ausmachen.

i=grep("t",z<-scan(,"",,,"\n"))
cat("Alex is",if(eval(parse(t=c(paste(LETTERS,"=",1:26),sample(rep(head(z,i-1),1e3)),paste(c(TRUE,sub("=","==",tail(z,-i))),collapse="&")))))"right"else"wrong")

Ich muss das ein bisschen entgolfen:

lines = scan(, what = "", sep = "\n")
therefore_idx = grep("therefore", lines)
setup = paste(LETTERS, "=", 1:26)
premises = sample(rep(head(lines, therefore_idx - 1), 1000))
propositions = paste(c(TRUE, sub("=", "==", tail(lines, -therefore_idx))), collapse = "&")
things_to_evaluate = c(setup, premises, propositions)
boolean_result = eval(parse(text = things_to_evaluate))
cat("Alex is", if (boolean_result) "right" else "wrong")

Zum Beispiel, wenn die Eingabe ist

A = B
B = C
therefore
A = C
B = C

es wird zuerst ausgewertet setup:

A = 1
B = 2
...
Z = 26

dann ist die premises

A = B
B = C

werden jeweils 1.000-mal in zufälliger Reihenfolge ausgeführt. Dies soll sicherstellen ("fast sicher"), dass alle Gleichheiten weitergegeben werden. Abschließend wird Folgendes ausgewertet propositions:

TRUE & A == B & B == C

Haskell, 208 Bytes

import Data.Equivalence.Persistent
c l=equate(l!!0)$last l 
r=foldr(c)$emptyEquivalence('A','Z')
l#r=equiv r(l!!0)$last l
f x|(h,_:t)<-span((<'t').head)$lines x="Alex is "++if all(#r h)t then"right"else"wrong"

Ich verlagere die Arbeit in das Data.Equivalence.PersistentModul, das Funktionen zum Bearbeiten von Äquivalenzklassen bereitstellt. Sie müssen nur die Eingabe- und Aufruffunktionen analysieren, die manchmal zu lange Namen haben, um richtig Golf zu spielen.

Anwendungsbeispiel:

*Main> f "A = B\nB = C\ntherefore\nA = C"
"Alex is right"

*Main> f "A = B\nB = D\ntherefore\nA = C"
"Alex is wrong"

Mathematica, 182

f[s_]:="Alex is "<>If[True===And@@Simplify[#2,#1]&@@(StringSplit[s,"\n"]/.{a___,"therefore",b___}:>StringSplit/@{{a},{b}}/.{x_,_,y_}:>Symbol[x<>"$"]==Symbol[y<>"$"]),"right","wrong"]

Funktioniert bei der Eingabe von Zeichenfolgen entsprechend der Herausforderung.

In[]:= f["A = B
B = C
therefore
A = C"]
Out[]= Alex is right

In[]:= f["D = K
D = Q
L = P
O = L
M = O
therefore
K = L"]
Out[]= Alex is wrong

Netzhaut, 90 Bytes

Platzieren Sie zum Ausführen die folgenden 12 Codezeilen in 12 separaten Dateien (+11 Byte, die für jede Datei nach der ersten gezählt werden). <empty>bezeichnet eine leere Datei; \nbezeichnet einen wörtlichen Zeilenumbruch. Alternativ können Sie das \ns so lassen, wie es ist, alle Zeilen in eine einzige Datei einfügen und die -sOption verwenden. Stellen Sie sicher, dass in allen Dateien Literal Newlines und nicht Windows verwendet werden \r\n, und beachten Sie das Leerzeichen am Ende der letzten Zeile.

s+`^(.) = (.)(.*)\1
$1 = $2$3$2
)`^. .+\n
<empty>
^.+|(.) = \1
<empty>
^\n*$
right
^[^r]+
wrong
^
Alex is 

Wie es funktioniert

Die erste Ersetzung entspricht der ersten Prämisse in der Eingabe, wenn die lhs der Prämisse später in der Datei auftreten. Es ersetzt dieses spätere Vorkommen durch das rechte der Prämisse. Der +Modifikator stellt sicher, dass das Ersetzen wiederholt wird, bis es nicht mehr übereinstimmt. Wenn also die erste Voraussetzung ist A = B, werden alle nachfolgenden As in der Datei in Bs umgewandelt.

Die zweite Ersetzung entfernt die erste Prämisse aus der Eingabe, da wir jetzt damit fertig sind. Dann )kehrt der Modifikator zur ersten Ersetzung zurück und wiederholt sich, bis sich in einem gesamten Durchlauf durch die Schleife nichts geändert hat. Dies geschieht, wenn alle Räumlichkeiten ersetzt und entfernt wurden und die Eingabe mit beginnt therefore.

Die dritte Ersetzung stimmt mit der ersten Eingabezeile (die therefore) oder einer beliebigen Form überein A = Aund löscht sie. Wenn alle Vorschläge von den Prämissen unterstützt werden, stimmen alle mit dieser Form überein. Was also übrig bleibt, sollte nur aus Zeilenumbrüchen bestehen. Die vierte Ersetzung ändert dies in right. Ansonsten ändert die fünfte Ersetzung alles Übrige (was rseitdem nicht mehr enthalten ist therefore) in wrong. Schließlich fügt die letzte Ersetzung Alex is zu Beginn hinzu.

Python 2, 264 Bytes

Es gibt bereits eine bemerkenswerte Python 3-Antwort von mbomb007 . Diese Antwort stiehlt flagrant von diesem einen (insbesondere der "Alex ist Wrriognhgt" -Trick).

Und diese Antwort ist auch deutlich länger als diese ...

In dieser Antwort geht es jedenfalls darum, ein Wörterbuch mit Schlüssel-Wert-Paaren zu führen, in dem die Schlüssel aus 26 Großbuchstaben bestehen und der entsprechende Wert jedes Schlüssels der Menge der Buchstaben entspricht, die dem Schlüssel entsprechen. (Wenn alle 26 Buchstaben gleich wären, hätte jeder Schlüssel einen Satz von 26 Buchstaben für den entsprechenden Wert.)

def a(s):
 d={C:set(C)for C in map(chr,range(65,91))};p,c=s.split('t');c,p=[x.split('\n')for x in[c[9:],p]]
 for u in p[:-1]:
    g,h=u[::4];y=d[g]|d[h]
    for v in y:
     for w in y:d[v]|=d[w];d[w]|=d[v]
 print'Alex is','wrriognhgt'[all(u[0]in d[u[4]]for u in c if u)::2]

(Um Bytes zu sparen, werden in dieser Antwort Leerzeichen und Tabulatoren gemischt , was in Python 2 zulässig ist.)

Dieser Code ist sehr effizient, da das Wörterbuch auf eine maximal mögliche Größe (26 mal 26, wie oben beschrieben) beschränkt ist, die nicht von der Anzahl der Eingabezeilen abhängt.

Als ich diese Lösung spielte, wurde mir klar, dass ich durch Ersetzen von Zeichenfolgen anstelle von Mengen für die Wörterbuchwerte vier Bytes einsparen konnte

d={C:set(C)for C in map(

mit

d={C:C for C in map(

Natürlich müssen Sie dann auch die drei Instanzen der Mengenvereinigungsoperation |durch Zeichenfolgenverkettung ersetzen (HINWEIS: TUN SIE DAS NICHT) +, aber das ändert nichts an der Codelänge. Das Ergebnis ist, dass alles immer noch genauso funktionieren sollte, außer dass Duplikate nicht beseitigt werden, wie dies bei Sets der Fall ist. Klingt in Ordnung - ein bisschen weniger effizient, aber 260 Bytes statt 264.

Nun, es stellt sich heraus, dass die 260-Byte-Version so ineffizient ist, dass es einen Fehler verursachte, MemoryErrorals ich sie mit testete

A = B
A = B
therefore
B = A

Das hat mich überrascht. Untersuchen wir die 260-Byte-Version "String-Verkettung"!

Natürlich würde es mit den Schlüssel-Wert-Paaren beginnen A:Aund B:B(plus 24 andere, die keine Rolle spielen). Wir werden schreiben d[A], um den Wörterbuchwert zu bezeichnen, der dem Schlüssel entspricht A, also hätten wir am Anfang d[A] = A. Nun, unter der Voraussetzung A = B, würde es damit beginnen, die Werte zu verketten d[A]=Aund d[B]=Bzu erhalten y = AB. Dann würde es diese Zeichenfolge zweimal durchlaufen: for v in AB: for w in AB:...

Also, das erste Mal durch die Schleife, haben wir v=Aund w=A. Anwendung d[v] += d[w]und d[w] += d[v]Ergebnisse in der folgenden Reihenfolge der Wörterbücher:

{A:A, B:B}      (start)
{A:AA, B:B}     (d[A] += d[A])
{A:AAAA, B:B}     (d[A] += d[A])

Weiter mit v=Aund w=B:

{A:AAAA, B:B}     (start)
{A:AAAAB, B:B}    (d[A] += d[B])
{A:AAAAB, B:BAAAAB}   (d[B] += d[A])

Als nächstes v=B, w=A:

{A:AAAAB, B:BAAAAB}   (start)
{A:AAAAB, B:BAAAABAAAAB}     (d[B] += d[A])
{A:AAAABBAAAABAAAAB, B:BAAAABAAAAB}     (d[A] += d[B])

Und v=B, w=B:

{A:AAAABBAAAABAAAAB, B:BAAAABAAAAB}     (start)
{A:AAAABBAAAABAAAAB, B:BAAAABAAAABBAAAABAAAAB}     (d[B] += d[B])
{A:AAAABBAAAABAAAAB, B:BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB}     (d[B] += d[B])

Die obige Abfolge von Schritten würde die einzelne Prämisse implementieren A = B, mit der Schlussfolgerung, dass Ajeder Buchstabe in der Zeichenfolge AAAABBAAAABAAAABund jeder Buchstabe in der Zeichenfolge Bgleich ist BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Angenommen, die nächste Voraussetzung ist A = B wieder . Sie berechnen zuerst y = d[A] + d[B] = AAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Als nächstes durchlaufen Sie diese Zeichenfolge zweimal: for v in y: for w in y:...

Ja. Vielleicht wäre das keine sehr effiziente Implementierung.

ES6, 128 Bytes

Lose basierend auf der Ruby-Version.

r=s=>(m=/^[^e]*(.) = (?!\1)(.)/.exec(s))?r(s.replace(RegExp(m[1],'g'),m[2])):'Alex is '+(/(.) = (?!\1)/.test(s)?'wrong':'right')

Sucht nach Ungleichheit vor dem "also" und ersetzt die Variable jedes Mal in der Zeichenfolge (dies spart Bytes über eine while-Schleife).

C 240 Bytes

#define V[v-65]
v[26];char*r[]={"wrong","right"};i=65;j;g(a){return a V^a?g(a V):a;}main(){char b[16];for(;i<91;++i)i V=i;while(gets(b)&&*b<99)b[0]V=b[4]V=b[0]V<b[4]V?b[0]V:b[4]V;while(gets(b))j|=g(*b)^g(b[4]);printf("Alex is %s\n",r[!j]);}

Dies funktioniert, indem Werte in Mengenbäumen kombiniert werden, sodass alle äquivalenten Werte zur gleichen Mengenwurzel führen. Ungolfed, mit expliziten impliziten Typen.

// Anything before `V` becomes an index into `v`, offset by -'A'.
#define V [v-65]
int v[26];
char* r[] = {"wrong", "right"};
int i=65;
int j;
// Finds a set identifier for a by recursing until some index points to itself.
int g(int a) {
    return a V ^ a
           ? g(a V)
           : a;
}
int main() {
    char b[16];
    // Initialize all entries to point to themselves.
    for(; i < 91; ++i)
        i V = i;
    // For each premise "A = B", set the entries for A and B to point to the
    // smaller of their current values. This exits after reading "therefore"
    // as 't' > 99.
    while (gets(b) && *b < 99)
        b[0]V = b[4]V = b[0]V < b[4]V
                        ? b[0]V
                        : b[4]V;
    // For each conclusion "A = B", OR j with non-zero if the set identifiers
    // for A and B are different.
    while (gets(b))
        j |= g(*b) ^ g(b[4]);
    printf("Alex is %s\n", r[!j]);
}

180 Bytes

Diese kürzere Version funktioniert in allen Fällen vom OP aus, aber für einige andere Eingaben behauptet Alex fälschlicherweise, dass sie falsch sind. Es verwendet einen ähnlichen Ansatz, setzt jedoch für jede Prämisse einfach den zweiten Eintrag auf den aktuellen Wert des ersten Eintrags. Beim Vergleich werden nur exakte Werte angezeigt, anstatt einen Baum zu durchsuchen.

v[26];*V=v-65;char*r[]={"wrong","right"};i;j;main(){char b[16];for(;i<26;++i)v[i]=i;while(gets(b)&&*b<99)V[b[4]]=V[*b];while(gets(b))j|=V[*b]^V[b[4]];printf("Alex is %s\n",r[!j]);}

Eine Beispieleingabe, für die dies fehlschlägt:

A = B
C = B
also
A = C

05AB1E , 32 Bytes

…±º€ˆ „–у©#|€á[ćD.l#`:}\€ËPè«.ª

Inspiriert von @aditsus CJam-Antwort .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

…±º€ˆ      # Push dictionary string "alex is "
„–у©      # Push dictionary string "wrong right"
     #     # Split by spaces: ["wrong","right"]
|          # Push all input-lines as list
 ۈ        # Only leave the letters of each line
   [       # Start an infinite loop:
    ć      #  Extract the head of the list; pop and push remainder-list and head separately
     D     #  Duplicate the head
      .l   #  If it's a lowercase string:
        #  #   Stop the infinite loop
    `      #  Push both letters in the string to the stack
     :     #  Replace all these letters in the remainder-list
 }\        # After the infinite loop: discard the duplicated "therefore"
   €       # For each letter-pair in the remainder list of condition-lines:
    Ë      #  Check if both letters are equal (1 if truhy; 0 if falsey)
   P       # Check if everything was truthy by taking the product
    è      # Use this to index into the earlier ["wrong","right"]-list
     «     # Append it to the "alex is " string
      .ª   # Sentence capitalize it
           # (after which the result is output implicitly)

Sehen Sie sich meinen Tipp 05AB1E (Abschnitt Wie verwende ich das Wörterbuch? ) An, um zu verstehen, warum es …±º€ˆist "alex is "und „–у©ist "wrong right".

Bash + Awk + SWI-Prolog , 167 Bytes

head -n1 <(awk '/therefore/{s=1;next};{if(s)print"?=("$1","$3")";else print};END{print"write(\"Alex is right\");write(\"Alex is wrong\"). halt."}' -|paste -sd ,|swipl)

Probieren Sie es online!

Ursprünglich war dies nur eine Prolog-Antwort, aber die Werkzeuge, die ich finden konnte, um das Eingabeformat tatsächlich in etwas Verwendbares zu verwandeln, waren so begrenzt, dass ich mich entschied, diesen Teil in bash zu machen, obwohl ich so gut wie keine Erfahrung hatte Ich tat irgendetwas in Bash und hatte noch nie Awk berührt. Am Ende habe ich genug Stunden damit verbracht, um es zu veröffentlichen, selbst nachdem es zu diesem 167-Byte-Monster herangewachsen war, das kaum Golf gespielt hat.

Im Grunde genommen übernimmt das awk-Programm die Eingabe von stdin, löscht die Zeile mit therefore, ersetzt A = Bsie danach mit ?=(A,B)und hängt sie an write(\"Alex is right\");write(\"Alex is wrong\"). halt.. Dann paste -sd ,ersetzt jede Neue - Zeile aber die letzte mit einem Komma, es in eine gültigen zwei Anfragen an die SWI-Prolog Schale Transformation, die dann mit dem Druckergebnis führen zu einer Linie abgeschnitten ist , durch head -n1, das erfordert <(...)aus Gründen anstelle einem Rohr jenseits mein Verständnis. All dies, nur um ein eingebautes zu verwenden !