¡Ayuda! ¡Mi calculadora funciona mal!

28

Introducción

Mi calculadora se está comportando raro. A veces, cuando escribo un 8, muestra un 2. Y a veces cuando escribo en una 6muestra una +. ¡Algunos botones están mezclados!
¿Alguien podría ayudarme a determinar cuál?

Reto:

Entrada: Lista de ecuaciones incorrectas , con resultados correctos .

Salida: los dos botones que se intercambian.

Por ejemplo:
una entrada podría ser:

123    = 3
8423   = 252
4+4    = 8
4*7-10 = 417
9/3    = 3
42-9   = -36

Para lo cual los resultados esperados son: 2y *.

¿Por qué? Porque TODAS las ecuaciones serían correctas si intercambiamos los 2 y *:

1*3    = 3
84*3   = 252
4+4    = 8
427-10 = 417
9/3    = 3
4*-9   = -36

Reglas de desafío:

  • La entrada puede estar en cualquier formato razonable. Puede ser una sola cadena con espacio delimitado; una lista de cadenas o una matriz; una lista con ecuaciones y otra lista con los resultados correctos. Tu llamada. ¡Indique qué formato de entrada ha utilizado!
    NOTA: Esto también significa que puede ingresar el caso de prueba -5--15como -5- -15o -5 - -15. Sin embargo, un número resultante --debe ingresarse sin espacios o con un espacio entre cada dígito. Por lo tanto, el caso de prueba 9119se puede ingresar como 9119o 9 1 1 9(la razón 91 19no está permitida es porque puede guiarse por el espacio para encontrar - -). Entonces los espacios son (algo) opcionales y permitidos.
  • El formato de salida puede estar en cualquier formato razonable también. Pueden ser dos personajes; una sola cadena de dos caracteres; una lista de cadenas que contiene los dos caracteres. Tu llamada. Una vez más, indique qué formato de salida ha utilizado.
  • Se le permite usar cualquier 14 salidas distintas que se asignen 0123456789+-*/. Por lo tanto, incluso puede emitir dos enteros distintos si lo desea (nuevamente, especifique la asignación que ha utilizado, si corresponde).
  • Solo tienes que soportar enteros. Por lo tanto, no habrá casos de prueba como 1/8=0.125o 1/8=0.
  • Operandos aritméticos que deberá admitir: suma ( +); resta ( -); multiplicación ( *o ×o ·); división ( /o ÷). (NOTA: Los caracteres entre paréntesis solo se agregan como aclaración).
  • Tendrás que soportar números negativos. Este medio -puede interpretarse en la ecuación como un operando matemático o un indicador negativo.
  • Puede suponer que las ecuaciones incorrectas dadas y las supuestas ecuaciones correctas siempre son válidas (por lo que no habrá cosas como 4-/2o 9+-+8por ejemplo).
  • Las ecuaciones de entrada incorrectas pueden contener una división por 0, pero las ecuaciones corregidas y esperadas nunca contendrán división por 0.
  • Las ecuaciones de entrada incorrectas ya pueden ser correctas incluso si cambia los botones deseados.
  • Una ecuación de entrada dada puede ser irrelevante para que los botones se intercambien (como las ecuaciones 4+4=8y 9/3=3, con los botones intercambiados 2y *).
  • Puede suponer que siempre habrá un único intercambio posible que se puede hacer con los casos de prueba dados.
  • Ambos botones para intercambiar siempre estarán presentes en al menos una de las ecuaciones incorrectas.

Reglas generales:

  • Este es el , por lo que la respuesta más corta en bytes gana.
    No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
  • Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
  • Las lagunas predeterminadas están prohibidas.
  • Si es posible, agregue un enlace con una prueba para su código.
  • Además, agregue una explicación si es necesario.

Casos de prueba:

Input:
123    = 3
8423   = 252
4+4    = 8
4*7-10 = 417
9/3    = 3
42-9   = -36

Output: 2 *

Input:
4/2   = 6
3/0   = 3
0/8+2 = 4
95-5  = 90
4+2   = 2

Output: + /

Input:
7+4    = 11
5-15   = 46
212-23 = -2121

Output: 1 -

Input:
4+8/2-9*1 = -5
99/3-13   = 20
1+2+3+4   = 10
4-3-2-1   = -6

Output: 2 4

Input:
18/18  = 1
98-8   = 90
55*88  = 4840
-5--15 = 10

Ouput: 5 8

Input:
9119    = 18
5-3     = 513
8*-9    = 152
13116/3 = -1

Output: 1 -
Kevin Cruijssen
fuente
2
"división real" significa que tenemos que soportar flotadores?
Erik the Outgolfer
@EriktheOutgolfer Vaya ... Copié eso de un desafío aritmético anterior mío. Eliminado, y como respuesta a su pregunta, no, solo tiene que lidiar con enteros.
Kevin Cruijssen
1
Sugeriría un caso de prueba donde contiene una ecuación correcta --. Por ejemplo 1991 = 2, -/3 = 3. (Muchos idiomas confunden esto con el operador de decremento)
Nwellnhof
1
El problema es que agregar un espacio 91 19si la solución es 9--9y no hay espacio 9119si la solución es 9229requiere conocimiento sobre la solución al crear los casos de prueba. Si esto se permitiera, simplemente podría agregar un espacio solo antes de los caracteres intercambiados y la solución podría derivarse inmediatamente del caso de prueba.
nwellnhof
1
Es la evaluación de izquierda a derecha, o *, y /antes +y binario -?
aschepler

Respuestas:

5

Perl 6 , 132113 bytes

Gracias a Jo King por -19 bytes.

->\e,$r {first {($!=e.trans($_=>.flip))ne e&&try "all {$!.&{S:g/\-/- /}} Z==$r".EVAL},[X~] (|^10,|<+ - * />)xx 2}

Pruébalo en línea!

La entrada es una cadena de ecuaciones separadas por comas y una cadena de resultados separados por comas (espero que esto esté bien). La salida es una cadena que contiene los dos botones intercambiados.

Maneja correctamente --. Producto podría falsos positivos para ---, ++, **, o //, pero no pudieron llegar a un caso de prueba.

nwellnhof
fuente
No tienes que manejarlo ---; ++; **; //; u otras cosas como *+etc. El único doble no adyacente sin dígitos que tendrás que soportar es --. Además, si entiendo su código correctamente, no lo necesitará .subst('-','- ', ya que -5--15se permite ingresar el caso de prueba con un espacio. No eres el primero en agregar código para agregar este espacio mediante programación, por lo que lo especificaré más claramente en la descripción del desafío.
Kevin Cruijssen
2
@KevinCruijssen Podría tener que manejar cosas como **porque tienen un significado como expresiones Perl 6 y pueden causar falsos positivos. 1992 = 1podría ser 1**2 = 1o 1//2 = 1, por ejemplo. Esto substes para los casos en que la ecuación correcta contiene --, por ejemplo, el nuevo caso de prueba que agregó.
nwellnhof
Su respuesta es actualmente la que tiene la menor cantidad de bytes, por lo que la aceptaré por ahora. Si a alguien se le ocurre algo más corto, el cheque podría cambiar nuevamente.
Kevin Cruijssen
113 bytes
Jo King
11

Javascript (ES7), 159 158 bytes

Editar: nueva versión para cumplir con las reglas actualizadas sobre --
1 byte guardado gracias a @Shaggy

Toma información en la sintaxis de curry (e)(r)donde e es la matriz de ecuaciones y r es la matriz de resultados esperados. Devuelve una matriz de caracteres.

e=>r=>(l=[...2**29+'4+-*/']).filter(x=>l.some(y=>eval("try{eval((S=(s=`[${e}]`).replace(/./g,c=>c==x?y:c==y?x:c)).split`--`.join`+`)+''==r&S!=s}catch(e){}")))

Casos de prueba

Formateado y comentado

e => r =>                                  // given e and r
  (l = [...2 ** 29 + '4+-*/'])             // generate l = [...'5368709124+-*/']
  .filter(x =>                             // for each character x of l
    l.some(y =>                            // for each character y of l
      eval("try {                          // we need to 'try', because we don't know
        eval(                              // whether the following expression is valid
          (S = (s = `[${e}]`).             // s = list of equations coerced to a string
            replace(/./g, c =>             // S =
              c == x ? y : c == y ? x : c  //   s with x and y exchanged
            )                              // end of replace()
          ).split`--`.join`+`              // replace '--' with '+'
        ) + '' == r                        // does the resulting list match r?
        & S != s                           // and was at least one character modified?
      } catch(e){}")                       // if we try, we oughta catch
    )                                      // end of some()
  )                                        // end of filter()
Arnauld
fuente
1
Creo que puede guardar un byte evaling try / catch: codepen.io/anon/pen/rzRrLp .
Shaggy
@ Shaggy Ah, sí, agradable. ¡Gracias!
Arnauld
Parece que esto podría funcionar para 139 bytes.
Shaggy
Sí, acabo de ejecutar un conjunto de pruebas completo y lo vi.
Shaggy
No funciona para 1991 = 2. La solución debe ser 1--1 = 2con 9y -intercambiado.
nwellnhof
4

Python 2 , 204 , 199 , 193 , 173 , 165 bytes

  • De 199 bytes a 193 bytes gracias al Sr. Xcode
  • De 193 bytes a 173 bytes gracias a Halvard Hummel
s=input()
r=str.replace
t=set(''.join(zip(*s)[0]))
for i in t:
 for j in t:
	try:
	 if all(eval(r(r(r(e,i,'$'),j,i),'$',j))==v*(i<j)for e,v in s):print i,j
	except:0

Pruébalo en línea!

mdahmoune
fuente
@ Mr.Xcoder gracias por el comentario, yo estoy arreglando ..
mdahmoune
1
@ Mr.Xcoder aquí está la versión corregida
mdahmoune
2
193 bytes
Sr. Xcoder
2
173 bytes
Halvard Hummel
4

Oracle SQL y PL / SQL, 458 bytes

La entrada puede estar en cualquier formato razonable. [...] una lista con ecuaciones y otra lista con los resultados correctos.

Compile la función PL / SQL (210 bytes):

CREATE FUNCTION f(x CHAR,y CHAR)RETURN NUMBER IS o NUMBER;BEGIN EXECUTE IMMEDIATE 'BEGIN :1:='||REPLACE(x,'--','- -')||';END;'USING OUT o;RETURN CASE o WHEN y THEN 1 END;EXCEPTION WHEN OTHERS THEN RETURN 0;END;

Ejecute el SQL (248 bytes):

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM T,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM T)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Después de haber creado una tabla Tcon los datos de prueba:

CREATE TABLE T(X,Y) AS
  SELECT '123',    3     FROM DUAL UNION ALL
  SELECT '8423',   252   FROM DUAL UNION ALL
  SELECT '4+4',    8     FROM DUAL UNION ALL
  SELECT '4*7-10', 417   FROM DUAL UNION ALL
  SELECT '9/3',    3     FROM DUAL UNION ALL
  SELECT '42-9',   -36   FROM DUAL

Salida:

V V_1
- ---
2 *
* 2

Versión previa :

Asumió una entrada de cadena como '123 = 3' :

Misma función PL / SQL y SQL (322 bytes):

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15),y(x,y)AS(SELECT REGEXP_SUBSTR(t,'[^=]+'),REGEXP_SUBSTR(t,'-?\d+$')FROM T)SELECT r.v,s.v FROM y,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM T)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Después de haber creado una tabla Tcon los datos de prueba:

CREATE TABLE T(T) AS
  SELECT '123    = 3'   FROM DUAL UNION ALL
  SELECT '8423   = 252' FROM DUAL UNION ALL
  SELECT '4+4    = 8'   FROM DUAL UNION ALL
  SELECT '4*7-10 = 417' FROM DUAL UNION ALL
  SELECT '9/3    = 3'   FROM DUAL UNION ALL
  SELECT '42-9   = -36' FROM DUAL;

Salida:

V V_1
- ---
2 *
* 2

Actualización - Prueba :

Violín de SQL

Configuración del esquema de Oracle 11g R2 :

CREATE FUNCTION F(x CHAR,y CHAR)RETURN NUMBER IS o NUMBER;BEGIN EXECUTE IMMEDIATE 'BEGIN :1:='||REPLACE(x,'--','- -')||';END;'USING OUT o;RETURN CASE o WHEN y THEN 1 END;EXCEPTION WHEN OTHERS THEN RETURN 0;END;
/

CREATE TABLE A(X,Y) AS
  SELECT '123',    3     FROM DUAL UNION ALL
  SELECT '8423',   252   FROM DUAL UNION ALL
  SELECT '4+4',    8     FROM DUAL UNION ALL
  SELECT '4*7-10', 417   FROM DUAL UNION ALL
  SELECT '9/3',    3     FROM DUAL UNION ALL
  SELECT '42-9',   -36   FROM DUAL
/

CREATE TABLE B(X,Y) AS
  SELECT '4/2',    6     FROM DUAL UNION ALL
  SELECT '3/0',    3     FROM DUAL UNION ALL
  SELECT '0/8+2',  4     FROM DUAL UNION ALL
  SELECT '95-5',   90    FROM DUAL UNION ALL
  SELECT '4+2',    2     FROM DUAL
/

CREATE TABLE C(X,Y) AS
  SELECT '7+4',    11    FROM DUAL UNION ALL
  SELECT '5-15',   46    FROM DUAL UNION ALL
  SELECT '212-23', -2121 FROM DUAL
/

CREATE TABLE D(X,Y) AS
  SELECT '4+8/2-9*1', -5 FROM DUAL UNION ALL
  SELECT '99/3-13',   20 FROM DUAL UNION ALL
  SELECT '1+2+3+4',   10 FROM DUAL UNION ALL
  SELECT '4-3-2-1',   -6 FROM DUAL
/

CREATE TABLE E(X,Y) AS
  SELECT '18/18',  1     FROM DUAL UNION ALL
  SELECT '98-8',   90    FROM DUAL UNION ALL
  SELECT '55*88',  4840  FROM DUAL UNION ALL
  SELECT '-5--15', 10    FROM DUAL
/

CREATE TABLE G(X,Y) AS
  SELECT '9119',    18   FROM DUAL UNION ALL
  SELECT '5-3',     513  FROM DUAL UNION ALL
  SELECT '8*-9',    152  FROM DUAL UNION ALL
  SELECT '13116/3', -1   FROM DUAL
/

Consulta 1 :

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM A,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM A)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Resultados :

| V | V |
|---|---|
| 2 | * |
| * | 2 |

Consulta 2 :

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM B,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM B)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Resultados :

| V | V |
|---|---|
| + | / |
| / | + |

Consulta 3 :

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM C,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM C)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Resultados :

| V | V |
|---|---|
| 1 | - |
| - | 1 |

Consulta 4 :

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM D,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM D)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Resultados :

| V | V |
|---|---|
| 2 | 4 |
| 4 | 2 |

Consulta 5 :

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM E,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM E)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Resultados :

| V | V |
|---|---|
| 5 | 8 |
| 8 | 5 |

Consulta 6 :

WITH r(v)AS(SELECT SUBSTR('1234567890-+*/',LEVEL,1)FROM DUAL CONNECT BY LEVEL<15)SELECT r.v,s.v FROM G,r,r s WHERE r.v<>s.v GROUP BY r.v,s.v HAVING SUM(f(TRANSLATE(x,r.v||s.v,s.v||r.v),y))=(SELECT COUNT(1)FROM G)AND SUM(INSTR(x,r.v)+INSTR(x,s.v))>0

Resultados :

| V | V |
|---|---|
| 1 | - |
| - | 1 |
MT0
fuente
No es necesario ||REPLACE(x,'--','- -')||, el formato de entrada / salida es flexible, por lo que puede ingresar -5--15como -5- -15lo desee. Además, ¿cuál sería la forma más fácil para mí de verificar que todos los casos de prueba funcionen, especialmente el último? ¿Es posible un enlace TIO de alguna manera?
Kevin Cruijssen
¿O se ||REPLACE(x,'--','- -')||usa para una ecuación correcta esperada, como el último caso de prueba que he agregado?
Kevin Cruijssen
1
@KevinCruijssen --comienza un comentario en SQL, por lo que los casos de prueba deben formularse para que --nunca ocurra en la ecuación (reemplazándola por - -) o necesita algo de codificación defensiva para militar por eso.
MT0
Entonces, para el último caso de prueba 13116/3 = -1, debería escribirse 131 16/3 = -1para eliminar esa llamada REPLACE.
MT0
Ah ok, entonces el reemplazo se usa para las ecuaciones correctas esperadas. Gracias por agregar el violín de SQL, +1 de mi parte.
Kevin Cruijssen
2

PowerShell, 222 209 192 bytes

param($x)1..13|%{0..(($i=$_)-1)|%{$a,$b='+-*/0123456789'[$i,$_]
$a+$b|?{!($x|%{$e,$r=$_-split'='
try{$r-(-join$(switch($e|% t*y){$a{$b}$b{$a}default{$_}})-replace'-',' -'|iex)}catch{1}}|gu)}}}

Prueba de guión y explicación:

$f={

param($x)                               # array of strings with equations
1..13|%{                                #
    0..(($i=$_)-1)|%{                   # $i and $_ contains unique couples of different indecies
        $a,$b='+-*/0123456789'[$i,$_]  # $a and $b contains buttons to swap
        $g=$x|%{                        # for each equation from array
            $e,$r=$_-split'='           # split incorrect expression and correct result
            $e=-join$(switch($e|% t*y){ # swap buttons for each symbol in the expression
                $a{$b}
                $b{$a}
                default{$_}
            })
            $e=$e-replace'-',' -'       # insert a space before each '-'.
                                        # It need to work with negative numbers.
                                        # For example, '4--1' throws an exception, '4 - -1' returns '5'
            try{$r-($e|iex)}catch{1}    # Try to calc $e as powershell expression
                                        # return 0 if the expression result equal to the result of the calculation
                                        # return non zero integer otherwise
        }|gu                            # Get-unique of calculation for each equation
        if(!$g){                        # if $g is 0 or $null
                                        # then all calculations returns true
            $a+$b                       # Ok, return the couple of buttons
        }
    }
}

}

@(
    ,('2*','123=3','8423=252','4+4=8','4*7-10=417','9/3=3','42-9=-36')
    ,('/+','4/2=6','3/0=3','0/8+2=4','95-5=90','4+2=2')
    ,('1-','7+4=11','5-15=46','212-23=-2121')
    ,('42','4+8/2-9*1=-5','99/3-13=20','1+2+3+4=10','4-3-2-1=-6')
    ,('1-','9119=18','5-3=513','8*-9=152','13116/3=-1')
) | % {
    $e,$x=$_
    $r=&$f $x
    "$($e-eq$r): $r : $x"
}

Salida:

True: 2* : 123=3 8423=252 4+4=8 4*7-10=417 9/3=3 42-9=-36
True: /+ : 4/2=6 3/0=3 0/8+2=4 95-5=90 4+2=2
True: 1- : 7+4=11 5-15=46 212-23=-2121
True: 42 : 4+8/2-9*1=-5 99/3-13=20 1+2+3+4=10 4-3-2-1=-6
True: 1- : 9119=18 5-3=513 8*-9=152 13116/3=-1
mazzy
fuente
0

05AB1E , 21 bytes

SÙãʒË_}ʒ¹s‡„--'+:.EQ

Ingrese como dos listas, primero las ecuaciones y segundo los resultados. Salida como una lista filtrada de pares con ambas rotaciones (es decir [["2","*"],["*","2"]]).

Pruébelo en línea o verifique todos los casos de prueba . (NOTA: Utiliza la versión heredada de 05AB1E en el TIO, porque .Eestá deshabilitada en la versión más reciente en TIO. Por eso, se agrega un adicional ï(conversión a entero), porque en la versión heredada de 05AB1E 1.0y las 1listas internas no eran iguales .)

Explicación:

S              # Convert the (implicit) input-list of equations to a list of characters
               # (which implicitly flattens)
               #  i.e. ["18/18","98-8","55*88","-5--15"]
               #   → ["1","8","/","1","8","9","8","-","8","5","5","*","8","8","-","5","-","-","1","5"]
 Ù             # Only leave all unique characters
               #  → ["1","8","/","9","-","5","*"]
  ã            # Cartesian product with itself; creating each possible pair of characters
               #  → [["1","1"],["1","8"],["1","/"],["1","9"],["1","-"],["1","5"],["1","*"],["8","1"],["8","8"],["8","/"],["8","9"],["8","-"],["8","5"],["8","*"],["/","1"],["/","8"],["/","/"],["/","9"],["/","-"],["/","5"],["/","*"],["9","1"],["9","8"],["9","/"],["9","9"],["9","-"],["9","5"],["9","*"],["-","1"],["-","8"],["-","/"],["-","9"],["-","-"],["-","5"],["-","*"],["5","1"],["5","8"],["5","/"],["5","9"],["5","-"],["5","5"],["5","*"],["*","1"],["*","8"],["*","/"],["*","9"],["*","-"],["*","5"],["*","*"]]
    ʒ  }       # Filter it by:
     Ë_        #  Where both characters are unique
               #   i.e. → [["1","8"],["1","/"],["1","9"],["1","-"],["1","5"],["1","*"],["8","1"],["8","/"],["8","9"],["8","-"],["8","5"],["8","*"],["/","1"],["/","8"],["/","9"],["/","-"],["/","5"],["/","*"],["9","1"],["9","8"],["9","/"],["9","-"],["9","5"],["9","*"],["-","1"],["-","8"],["-","/"],["-","9"],["-","5"],["-","*"],["5","1"],["5","8"],["5","/"],["5","9"],["5","-"],["5","*"],["*","1"],["*","8"],["*","/"],["*","9"],["*","-"],["*","5"]]
    ʒ          # Then filter the pairs again by:
     ¹         #  Push the first input-list with equations
      s        #  Swap to take the pair we're filtering
       Â       #  Bifurcate it (short for Duplicate and Reverse)
              #  Transliterate; replacing the characters at the same indices in the input-list
               #   i.e. ["18/18","98-8","55*88","-5--15"] and ["8","5"]
               #    → ["15/15","95-5","88*55","-8--18"]
               #   i.e. ["9119","5-3","8*-9","13116/3"] and ["1","-"]
               #    → ["9--9","513","8*19","-3--6/3"]
      „--'+:  '#  Then replace all "--" with a "+"
               #   → ["15/15","95-5","88*55","-8+18"]
               #   → ["9+9","513","8*19","-3+6/3"]
      .E       #  And evaluate the strings with Python eval
               #   → [1.0,90,4840,10]
               #   → [18,513,152,-1.0]
        Q      #  And then check if this evaluated list is equal to the (implicit) second input
               #   i.e. [1.0,90,4840,10] and [1,90,4840,10] → 1 (truthy)
               #   i.e. [18,513,152,-1.0] and [18,513,152,-1] → 1 (truthy)
               # (and output the result implicitly)
               #   i.e. [["8","5"],["5","8"]
               #   i.e. [["1","-"],["-","1"]
Kevin Cruijssen
fuente