_{Este desafío es levantar el espíritu de nuestro mod Alex A. , que generalmente se equivoca .}

Supongamos que tiene un amigo llamado Alex que necesita ayuda con la lógica básica y las matemáticas, específicamente la equivalencia matemática .

Te da una lista de ecuaciones de la forma [variable] = [variable]en la que a [variable]siempre es una letra mayúscula de la A a la Z (no una letra minúscula, ni un número, ni ninguna otra cosa). Hay una ecuación por línea en la lista, excepto por una sola línea que solo dice therefore.

Todas las ecuaciones anteriores thereforeson premisas , hechos que se suponen verdaderos. Todas las ecuaciones a continuación thereforeson proposiciones no verificadas, hechos que Alex intenta inferir de las premisas, y pueden o no ser ciertas.

Por ejemplo, en esta lista de ecuaciones, la proposición concluyente única A = Ces verdadera:

A = B
B = C
therefore
A = C

Es su trabajo decirle a Alex si todas sus proposiciones se siguen lógicamente de las premisas dadas. Es decir, debe decirle a Alex si está equivocado o correcto en sus conclusiones.

Escriba un programa / función que tome una cadena de una lista de ecuaciones como se describe e imprime / devuelve

Alex is right

si todas las conclusiones se siguen lógicamente de las premisas y, de lo contrario, salen

Alex is wrong

si alguna conclusión no se deduce lógicamente de las premisas.

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

Asegúrese de estar atento a estos casos:

• La variable siempre se iguala a sí misma. p.ej

  B = A
  therefore
  A = A
  X = X
  

  resultados en Alex is right.

• No se puede suponer que las variables con relaciones desconocidas sean iguales. p.ej

  P = Q
  therefore
  E = R
  

  resultados en Alex is wrong.

• Cuando no hay ecuaciones después de thereforeentonces, las conclusiones son vacías . p.ej

  D = C
  therefore

  y

  therefore

  ambos resultan en Alex is right.

• Cuando no hay ecuaciones antes, thereforeentonces solo se puede inferir la auto-igualdad. p.ej

  therefore
  R = R
  

  resulta en Alex is right, pero

  therefore
  R = W
  

  resultados en Alex is wrong.

Más ejemplos

Alex tiene casos incorrectos: (separados por líneas vacías)

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 tiene razón casos:

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"?

Inspirado en la solución Ruby de histocrat. Pruébelo en línea
3 bytes borrados gracias a jimmy23013 :)

Explicación:

Para cada premisa, el programa reemplaza la primera variable con la segunda variable en el resto del texto. Luego verifica si hay alguna conclusión con diferentes variables.

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

Versión anterior, 85

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

Esto utiliza un algoritmo de búsqueda de unión. Pruébalo en línea

Rubí, 80 76 + 2 = 78

Con banderas de línea de comandos p0, ejecute

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

Explicación:

Esto utiliza la manipulación de cadenas pura. p0lee la entrada completa como una sola cadena en la variable $_. Luego, repetidamente hacemos coincidir esa cadena con la expresión regular /(.) = (?!\1)(.)/, que encuentra todas las cadenas de la forma "X = Y" donde X e Y no son la misma letra, y asigna X a $ 1 e Y a $ 2. Cuando se encuentra dicha coincidencia, gsub$1,$2reemplaza todas las instancias de X con Y en la cadena. También verificamos si esta coincidencia ocurrió antes o después del "por lo tanto" con

$`[/e/]

Si ocurrió después, es un reclamo injustificado y Alex está equivocado. Realizamos un seguimiento de si se han producido dichos sucesos utilizando p=. El uso de pcomo una variable de seguimiento evita que las cosas se rompan si el bucle nunca golpea ni siquiera una vez, ya pque volverá nulo si nunca se le asignó.

A partir de esta publicación, la solución CJam es más larga. Un momento orgulloso, sin duda fugaz.

Editar: Sí, rápidamente destronado. Además, para finalizar la explicación, con el pindicador, el valor final de $_se emite al final de la ejecución, por lo que la última línea es la salida.

CJam, 83 75 68 67 64 bytes

Gracias a Dennis por guardar 1 byte.

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

Banco de pruebas. Los casos de prueba son demasiado largos para un enlace permanente, así que simplemente cópielos de la pregunta. Tenga en cuenta que esto es bastante lento: lleva un minuto o dos en el intérprete en línea. Puede que sea mucho más rápido cambiando 5*a 2*en cuyo caso se terminará casi al instante y resolver todos menos un caso de prueba.

Explicación

(Ligeramente anticuado)

La idea es hacer una especie de "relleno de inundación" de posibles igualdades y luego eliminar todas las igualdades que obtuvimos de la lista de conclusiones. Se puede demostrar que no necesitamos más de 5 pasos del relleno de inundación, porque cubrirían una distancia (en el gráfico inicial de desigualdades) de pero la distancia máxima es 25.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

He modificado mi respuesta para abordar una limitación señalada por el usuario2357112. Todavía hay una probabilidad extremadamente pequeña de llamar a Alex cuando en realidad tiene razón (lo que en sí mismo no parece suceder muy a menudo si entiendo el contexto del desafío :-). Espero que no le importe.

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")

Necesito desempacar esto un poco:

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")

Por ejemplo, si la entrada es

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

Primero evaluará setup:

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

entonces la premises

A = B
B = C

se ejecutará 1,000 veces cada uno en un orden aleatorio. Esto es para asegurarse ("casi seguro") de que todas las igualdades se propagan. Finalmente, evaluará 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"

Estoy descargando el trabajo al Data.Equivalence.Persistentmódulo, que proporciona funciones para manipular clases de equivalencia. Todo lo que queda por hacer es analizar la entrada y las funciones de llamada que a veces tienen nombres demasiado largos para el golf adecuado.

Ejemplo de uso:

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

Funciona en la entrada de cadena, según el desafío.

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

Retina, 90 bytes

Para ejecutar, coloque las siguientes 12 líneas de código en 12 archivos separados (+11 bytes contados para cada archivo más allá del primero). <empty>designa un archivo vacío; \ndesigna una nueva línea literal. Alternativamente, mantenga las \ns como están, coloque todas las líneas en un solo archivo y use la -sopción. Asegúrese de que todos los archivos usen nuevas líneas literales, no Windows \r\n, y tenga en cuenta el espacio al final de la última línea.

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

Cómo funciona

El primer reemplazo coincide con la primera premisa en la entrada, siempre que el lhs de la premisa ocurra más adelante en el archivo. Reemplaza esa ocurrencia posterior con la derecha de la premisa. El +modificador asegura que el reemplazo se repita hasta que ya no coincida. Por lo tanto, si la primera premisa es A = B, todos los As posteriores en el archivo se transmutan en Bs.

El segundo reemplazo elimina la primera premisa de la entrada, ya que hemos terminado con ella ahora. Luego, el )modificador regresa al primer reemplazo y se repite hasta que no haya cambios en un pase completo a través del ciclo. Esto sucede cuando todas las premisas han sido sustituidas y eliminadas, y la entrada comienza con therefore.

El tercer reemplazo coincide con la primera línea de entrada (que es therefore) o cualquier cosa del formulario A = A, y lo elimina. Si todas las proposiciones son compatibles con las premisas, todas coincidirán con este formulario, por lo que lo que quede debe consistir únicamente en nuevas líneas. El cuarto reemplazo cambia esto a right. De lo contrario, el quinto reemplazo cambia todo lo que queda (que no contiene rdesde que thereforese eliminó) wrong. Finalmente, el último reemplazo se agrega Alex is al principio.

Python 2, 264 bytes

Ya hay una notable respuesta de Python 3 por mbomb007 . Esta respuesta le roba flagrantemente a esa (en particular, el truco "Alex está escribiendo").

Y esta respuesta también es significativamente más larga que esa ...

Bueno, de todos modos, la idea en esta respuesta es mantener un diccionario de pares clave-valor, donde las claves son los 26 caracteres en mayúscula, y el valor correspondiente de cada clave es el conjunto de letras que son equivalentes a la clave. (Si las 26 letras fueran equivalentes, entonces cada tecla tendría un conjunto de 26 letras para su valor correspondiente).

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]

(Para guardar bytes, esta respuesta mezcla espacios y pestañas , lo cual es legal en Python 2.)

Este código es realmente bastante eficiente, porque el diccionario está limitado a un tamaño máximo posible (26 por 26 como se describe anteriormente) que no depende del número de líneas de entrada.

Ahora, mientras jugaba esta solución, me di cuenta de que podía ahorrar cuatro bytes usando cadenas en lugar de conjuntos para los valores del diccionario, reemplazando

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

con

d={C:C for C in map(

Por supuesto, también debe reemplazar (NOTA: NO HAGA ESTO) las tres instancias de la operación de unión de conjunto | con concatenación de cadenas +, pero eso no cambia la longitud del código. El resultado es que todo debería funcionar igual, excepto que no eliminará duplicados como lo hace con los conjuntos (simplemente seguirá agregando al final de la cadena). Suena bien, un poco menos eficiente, claro, pero 260 bytes en lugar de 264.

Bueno, resulta que la versión de 260 bytes es tan ineficiente que causó unMemoryError cuando la probé con

A = B
A = B
therefore
B = A

Esto fue sorprendente para mí. ¡Investiguemos la versión de "concatenación de cadenas" de 260 bytes!

Por supuesto, comenzaría con los pares clave-valor A:Ay B:B(más otros 24 que no importan). Escribiremos d[A]para significar el valor del diccionario correspondiente a la clave A, por lo que al principio tendríamos d[A] = A. Ahora, dada la premisa A = B, comenzaría por concatenar los valores d[A]=Ay d[B]=Bobtenery = AB . Luego, pasaría por esta cadena dos veces: for v in AB: for w in AB:...

Entonces, la primera vez a través del ciclo, tenemos v=Ay w=A. Aplicación d[v] += d[w]y d[w] += d[v]resultados en la siguiente secuencia de diccionarios:

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

A continuación, con v=Ay w=B:

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

A continuación 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])

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

La secuencia de pasos anterior implementaría la premisa única A = B, con la conclusión de que Aes igual a cada letra en la cadena AAAABBAAAABAAAAB, mientras que Bes igual a cada letra en BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Ahora, supongamos que la próxima premisa es A = B nuevamente . Primero calculas y = d[A] + d[B] = AAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Luego, repite esta cadena dos veces: for v in y: for w in y:...

Sí. Tal vez esa no sería una implementación muy eficiente.

ES6, 128 bytes

Basada en la versión Ruby.

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

Busca cualquier no auto-igualdad antes del "por lo tanto" y reemplaza repetidamente la variable a lo largo de la cadena cada vez (esto ahorra bytes en un ciclo while).

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

Esto funciona combinando valores en árboles de conjunto, por lo que cualquier valor equivalente conduce a la misma raíz de conjunto. Sin golf, con tipos implícitos hechos explícitos.

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

Esta versión más corta funciona para todos los casos desde el OP, pero para algunas otras entradas afirma incorrectamente que Alex está equivocado. Utiliza un enfoque similar, pero para cada premisa simplemente establece la segunda entrada al valor actual de la primera entrada. Al comparar, solo busca valores exactos en lugar de buscar un árbol.

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

Un ejemplo de entrada para el que esto falla:

A = B
C = B
por lo tanto
A = C

05AB1E , 32 bytes

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

Inspirado por @aditsu respuesta Cjam 's .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

…±º€ˆ      # 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)

Vea esta sugerencia mía 05AB1E (sección ¿Cómo usar el diccionario? ) Para comprender por qué …±º€ˆes "alex is "y „–у©es "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)

Pruébalo en línea!

Originalmente, esto solo iba a ser una respuesta de Prolog, pero las herramientas que pude encontrar para transformar realmente el formato de entrada en algo utilizable fueron lo suficientemente limitadas que decidí hacer esa parte en bash, a pesar de que casi no tenía experiencia haciendo cualquier cosa en bash, y nunca había tocado awk. Terminé pasando suficientes horas en él para querer publicarlo incluso después de que se convirtió en este 167 bytes, apenas golfizado en absoluto.

Esencialmente, lo que hace el programa awk es tomar la entrada de stdin, borrar la línea con therefore, reemplazar cada A = Bdespués con ?=(A,B)y agregar write(\"Alex is right\");write(\"Alex is wrong\"). halt.. Luego, paste -sd ,reemplaza cada línea nueva pero la última con una coma, transformándola en dos consultas válidas para el shell SWI-Prolog, que luego se ejecutan con el resultado impreso truncado en una línea head -n1, lo que requiere en <(...)lugar de una tubería por razones más allá mi punto de vista. Todo esto, solo para usar un incorporado !