Wsparcie! Mój kalkulator działa nieprawidłowo!

28

Wprowadzenie

Mój kalkulator zachowuje się dziwnie. Czasami, gdy wpisuję 8, wyświetla się 2. A czasami, gdy wpisuję 6, wyświetla się +. Niektóre przyciski są pomieszane!
Czy ktoś mógłby mi pomóc ustalić, który?

Wyzwanie:

Dane wejściowe: lista niepoprawnych równań z poprawnymi wynikami.

Wyjście: dwa zamienione przyciski.

Na przykład:
dane wejściowe mogą być:

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

Dla których oczekiwane wyniki to: 2i *.

Czemu? Ponieważ WSZYSTKIE równania byłyby poprawne, gdybyśmy zamienili 2 i *:

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

Zasady konkursu:

  • Dane wejściowe mogą mieć dowolny rozsądny format. Może być pojedynczym ciągiem z ogranicznikiem spacji; lista ciągów lub tablica; lista z równaniami i inna lista z poprawnymi wynikami. Twoja decyzja. Proszę podać używany format wejściowy!
    UWAGA: Oznacza to również, że możesz wprowadzić przypadek testowy -5--15jako -5- -15lub -5 - -15. Jednak wynikową liczbę --należy wprowadzić bez spacji lub ze spacją między każdą cyfrą. Tak więc przypadek testowy 9119można wprowadzić jak 9119lub 9 1 1 9(powód 91 19jest niedozwolony, ponieważ można następnie kierować się przestrzenią do znalezienia - -). Więc spacje są (nieco) opcjonalne i dozwolone.
  • Format wyjściowy może być również w dowolnym rozsądnym formacie. Mogą być dwie postacie; pojedynczy dwuznakowy ciąg; lista ciągów zawierająca dwa znaki. Twoja decyzja. Ponownie, proszę podać używany format wyjściowy!
  • Możesz używać dowolnych 14 wyjściowych mapowań 0123456789+-*/. Więc możesz nawet wypisać dwie różne liczby całkowite, jeśli chcesz (ponownie, proszę podać zastosowane mapowanie, jeśli istnieje).
  • Musisz tylko obsługiwać liczby całkowite. Więc nie będzie żadnych przypadków testowych takich jak 1/8=0.125lub 1/8=0.
  • Operandy arytmetyczne, które będziesz musiał obsługiwać: add ( +); odejmowanie ( -); mnożenie ( *lub ×lub ·); podział ( /lub ÷). (UWAGA: Znaki między nawiasami są dodawane jedynie jako wyjaśnienie).
  • Będziesz musiał obsługiwać liczby ujemne. Środki -te można interpretować w równaniu jako zarówno argument matematyczny, jak i wskaźnik ujemny.
  • Można założyć, podane nieprawidłowe równań i rzekome poprawne równania są zawsze aktualne (więc nie będzie rzeczy, jak 4-/2i 9+-+8na przykład).
  • Niepoprawne równania wejściowe mogą zawierać podział przez 0, ale poprawione i oczekiwane równania nigdy nie będą zawierać podziału przez 0.
  • Niepoprawne równania wejściowe mogą już być poprawne, nawet jeśli zamienisz zamierzone przyciski z powrotem.
  • Dany równanie wejściowy może być istotne dla przycisków do wymiany (jak 4+4=8i 9/3=3równań, z zamienione przycisków 2i *).
  • Możesz założyć, że zawsze będzie tylko jedna możliwa zamiana, którą można wykonać dla danych przypadków testowych.
  • Oba przyciski zamiany będą zawsze obecne w co najmniej jednym z niepoprawnych równań.

Główne zasady:

  • To jest , więc wygrywa najkrótsza odpowiedź w bajtach.
    Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
  • Do odpowiedzi mają zastosowanie standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i zwracanymi typami, pełnych programów. Twoja decyzja.
  • Domyślne luki są zabronione.
  • Jeśli to możliwe, dodaj link z testem swojego kodu.
  • W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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
źródło
2
„prawdziwy podział” oznacza, że ​​musimy wspierać zmiennoprzecinkowe?
Erik the Outgolfer,
@EriktheOutgolfer Oops .. Skopiowałem to z mojego poprzedniego zadania arytmetycznego. Usunięto i jako odpowiedź na twoje pytanie nie musisz zajmować się tylko liczbami całkowitymi.
Kevin Cruijssen
1
Sugerowałbym przypadek testowy, w którym zawiera prawidłowe równanie --. Na przykład 1991 = 2, -/3 = 3. (Wiele języków myli to z operatorem dekrementacji.)
nwellnhof,
1
Problem polega na tym, że dodanie spacji w 91 19przypadku rozwiązania 9--9i brak spacji w 9119przypadku rozwiązania 9229wymaga wiedzy na temat rozwiązania podczas tworzenia przypadków testowych. Gdyby to było dozwolone, mógłbym po prostu dodać spację tylko przed zamienionymi znakami, a rozwiązanie mogłoby zostać natychmiast uzyskane z przypadku testowego.
nwellnhof
1
Czy ocena z lewej do prawej, czy *i /przed +i binarnym -?
aschepler

Odpowiedzi:

5

Perl 6 , 132 113 bajtów

Dzięki Jo King za -19 bajtów.

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

Wypróbuj online!

Dane wejściowe to ciąg równań oddzielony przecinkami i ciąg wyników oddzielony przecinkami (mam nadzieję, że jest to w porządku). Dane wyjściowe to ciąg zawierający dwa zamienione przyciski.

Prawidłowo obsługuje --. Produkt może fałszywie dodatnie dla ---, ++, **, lub //, ale nie mogłem wymyślić przypadku testowego.

nwellnhof
źródło
Nie musisz się tym zajmować ---; ++; **; //; lub inne rzeczy, takie jak *+itp. Jedynym podwójnym sąsiadującym niecałkowym numerem, który musisz obsługiwać, jest --. Ponadto, jeśli dobrze rozumiem twój kod, nie będziesz potrzebować .subst('-','- ', ponieważ -5--15dozwolone jest wprowadzanie przypadku testowego ze spacją. Nie jesteś pierwszym, który dodaje kod, aby programowo dodać tę przestrzeń, więc sprecyzuję to w opisie wyzwania.
Kevin Cruijssen
2
@KevinCruijssen Być może będę musiał sobie poradzić z takimi rzeczami, **ponieważ mają one znaczenie jako wyrażenia Perla 6 i mogą powodować fałszywe alarmy. 1992 = 1może być 1**2 = 1lub 1//2 = 1, na przykład. Dotyczy substprzypadków, w których prawidłowe równanie zawiera --, na przykład dodanego nowego przypadku testowego.
nwellnhof
Twoja odpowiedź jest obecnie z najmniejszą liczbą bajtów, więc na razie ją zaakceptuję. Jeśli ktoś wpadnie na coś krótszego, czek może się zmienić.
Kevin Cruijssen,
113 bajtów
Jo King,
11

JavaScript (ES7), 159 158 bajtów

Edycja: nowa wersja zgodna ze zaktualizowanymi zasadami dotyczącymi --
Zapisanego 1 bajtu dzięki @Shaggy

Pobiera dane wejściowe w składni curry, (e)(r)gdzie e jest tablicą równań, a r jest tablicą oczekiwanych wyników. Zwraca tablicę znaków.

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

Przypadki testowe

Sformatowane i skomentowane

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
źródło
1
Myślę, że można zapisać bajt przez evalnia się try / catch: codepen.io/anon/pen/rzRrLp .
Shaggy
@Shaggy Ah tak, miło. Dzięki!
Arnauld
Wygląda na to, że może to działać dla 139 bajtów.
Shaggy
Tak, właśnie uruchomiłem pełny zestaw testów i to zauważyłem.
Shaggy
Nie działa dla 1991 = 2. Roztwór powinien być 1--1 = 2z 9i -zamienione.
nwellnhof
4

Python 2 , 204 , 199 , 193 , 173 , 165 bajtów

  • Od 199 bajtów do 193 bajtów dzięki Mr. Xcode
  • Od 193 bajtów do 173 bajtów dzięki Halvardowi Hummelowi
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

Wypróbuj online!

mdahmoune
źródło
@ Mr.Xcoder dzięki za uwagę, naprawiam to.
mdahmoune,
1
@ Mr.Xcoder tutaj jest poprawiona wersja
mdahmoune,
2
193 bajtów
Mr. Xcoder,
2
173 bajtów
Halvard Hummel
4

Oracle SQL i PL / SQL, 458 bajtów

Dane wejściowe mogą mieć dowolny rozsądny format. [...] lista z równaniami i inna lista z poprawnymi wynikami.

Skompiluj funkcję PL / SQL (210 bajtów):

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;

Uruchom SQL (248 bajtów):

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

Po utworzeniu tabeli Tz danymi testowymi:

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

Wydajność:

V V_1
- ---
2 *
* 2

Poprzednia wersja :

Przyjęto ciąg znaków, taki jak '123 = 3':

Ta sama funkcja PL / SQL i SQL (322 bajty):

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

Po utworzeniu tabeli Tz danymi testowymi:

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;

Wydajność:

V V_1
- ---
2 *
* 2

Aktualizacja - testowanie :

SQL Fiddle

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

Zapytanie 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

Wyniki :

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

Zapytanie 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

Wyniki :

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

Zapytanie 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

Wyniki :

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

Zapytanie 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

Wyniki :

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

Zapytanie 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

Wyniki :

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

Zapytanie 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

Wyniki :

| V | V |
|---|---|
| 1 | - |
| - | 1 |
MT0
źródło
Nie ma potrzeby ||REPLACE(x,'--','- -')||, format wejścia / wyjścia jest elastyczny, więc możesz wprowadzać dane -5--15tak -5- -15, jak chcesz. Ponadto, jaki byłby dla mnie najłatwiejszy sposób zweryfikowania działania wszystkich przypadków testowych, zwłaszcza ostatniego? Czy link TIO jest w jakiś sposób możliwy?
Kevin Cruijssen
A może ||REPLACE(x,'--','- -')||używa się oczekiwanego poprawnego równania, takiego jak ostatnio dodany przypadek testowy?
Kevin Cruijssen
1
@KevinCruijssen --rozpoczyna komentarz w SQL, więc albo przypadki testowe muszą zostać sformułowane, aby --nigdy nie występowały w równaniu (zamieniając je na - -), lub potrzebuje jakiegoś defensywnego kodowania, aby to usprawiedliwić.
MT0,
Więc dla ostatniego przypadku testowego 13116/3 = -1należałoby napisać, 131 16/3 = -1aby usunąć to wezwanie do REPLACE.
MT0
Ach ok, więc zamiana jest rzeczywiście używana do oczekiwanych poprawnych równań. Dzięki za dodanie skrzypce SQL, +1 ode mnie.
Kevin Cruijssen
2

PowerShell, 222 209 192 bajtów

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

Skrypt testowy i objaśnienie:

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

Wydajność:

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
źródło
0

05AB1E , 21 bajtów

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

Dane wejściowe jako dwie listy, pierwsza to równania, a druga wyniki. Wyjście w postaci przefiltrowanej listy par z obydwoma obrotami (tj [["2","*"],["*","2"]].).

Wypróbuj online lub sprawdź wszystkie przypadki testowe . (UWAGA: Używa starszej wersji 05AB1E w TIO, ponieważ .Ejest wyłączona w nowszej wersji w TIO. Z tego powodu ïdodawana jest dodatkowa (rzut na liczbę całkowitą), ponieważ w starszej wersji 05AB1E 1.0i 1wewnętrzne listy nie były równe .)

Wyjaśnienie:

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
źródło