Aiuto! La mia calcolatrice non funziona correttamente!


28

introduzione

La mia calcolatrice si sta comportando in modo strano. A volte quando scrivo un 8viene visualizzato a 2. E a volte quando scrivo a 6viene visualizzato a +. Alcuni pulsanti sono confusi!
Qualcuno potrebbe aiutarmi a determinare quale?

Sfida:

Input: elenco di equazioni errate , con risultati corretti .

Output: i due pulsanti che vengono scambiati.

Ad esempio:
un input potrebbe essere:

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

Per cui gli output previsti sono: 2e *.

Perché? Perché TUTTE le equazioni sarebbero corrette se scambiassimo i 2 e *:

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

Regole della sfida:

  • L'input può essere in qualsiasi formato ragionevole. Può essere una singola stringa con spazio delimitato; una lista-string o -array; un elenco con equazioni e un altro elenco con i risultati corretti. La tua chiamata. Indica quale formato di input hai utilizzato!
    NOTA: ciò significa anche che è consentito inserire il test case -5--15come -5- -15o -5 - -15. Tuttavia, un numero risultante --deve essere immesso senza spazi o con uno spazio tra ogni cifra. Quindi il test case 9119può essere inserito come 9119o 9 1 1 9(la ragione 91 19non è consentita perché puoi quindi essere guidato dallo spazio per la ricerca - -). Quindi gli spazi sono (in qualche modo) opzionali e ammessi.
  • Anche il formato di output può essere in qualsiasi formato ragionevole. Possono essere due personaggi; una singola stringa di due caratteri; un elenco di stringhe contenente i due caratteri. La tua chiamata. Ancora una volta, per favore indica quale formato di output hai usato!
  • È consentito utilizzare 14 distinti output su cui mappare 0123456789+-*/. Quindi, se vuoi, puoi anche generare due interi distinti (di nuovo, specifica l'eventuale mappatura che hai usato).
  • Devi solo supportare numeri interi. Quindi non ci saranno casi di test come 1/8=0.125o 1/8=0.
  • Operandi aritmetici che dovrai supportare: addition ( +); sottrazione ( -); moltiplicazione ( *o ×o ·); divisione ( /o ÷). (NOTA: i caratteri tra parentesi vengono aggiunti solo come chiarimento.)
  • Dovrai supportare numeri negativi. Questo significa che -può essere interpretato nell'equazione sia come operando matematico sia come indicatore negativo.
  • Puoi assumere le equazioni errate fornite e le presunte equazioni corrette sono sempre valide (quindi non ci saranno cose come 4-/2o 9+-+8per esempio).
  • Le equazioni di input errate possono contenere una divisione per 0, ma le equazioni corrette e previste non conterranno mai una divisione per 0.
  • Le equazioni di input errate possono già essere corrette anche se si scambiano di nuovo i pulsanti desiderati.
  • Una data equazione di input può essere irrilevante per i pulsanti da scambiare (come le equazioni 4+4=8e 9/3=3, con i pulsanti scambiati 2e *).
  • Puoi presumere che ci sarà sempre solo uno scambio possibile che può essere effettuato con i casi di test indicati.
  • Entrambi i pulsanti da scambiare saranno sempre presenti in almeno una delle equazioni errate.

Regole generali:

  • Questo è , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Sono vietate le scappatoie predefinite .
  • Se possibile, aggiungi un link con un test per il tuo codice.
  • Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi test:

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 -
code-golf  number  arithmetic  integer  code-golf  math  number  geometry  code-golf  grid  code-golf  math  number  sequence  primes  code-golf  sequence  kolmogorov-complexity  code-golf  string  ascii-art  alphabet  code-golf  math  sequence  integer  code-golf  number-theory  integer  natural-language  code-golf  date  code-golf  function  code-golf  ascii-art  code-golf  math  number-theory  primes  classification  code-golf  array-manipulation  decision-problem  matrix  code-golf  number  code-golf  code-golf  ascii-art  matrix  code-golf  string  code-golf  sequence  base-conversion  code-golf  code-golf  math  number-theory  combinatorics  integer-partitions  code-golf  integer  binary  base-conversion  code-golf  integer  base-conversion  palindrome  code-golf  code-golf  integer-partitions  code-golf  math  ascii-art  matrix  code-golf  number  sequence  number-theory  matrix  code-golf  interpreter  code-golf  graph-theory  code-golf  ascii-art  decision-problem  code-golf  division  code-golf  array-manipulation  primes  code-golf  string  ascii-art  code-golf  primes  counting  code-golf  matrix  unicode  code-golf  source-layout  code-golf  grammars  code-golf  string  cops-and-robbers  regular-expression  obfuscation  string  code-challenge  cops-and-robbers  regular-expression  code-golf  kolmogorov-complexity  game  card-games  code-golf  kolmogorov-complexity  code-golf  array-manipulation  matrix  code-challenge  cops-and-robbers  code-challenge  decision-problem  cops-and-robbers  code-golf  permutations 

2
"vera divisione" significa che dobbiamo supportare i float?
Erik the Outgolfer,

@EriktheOutgolfer Oops .. L'ho copiato da una mia precedente sfida aritmetica. Rimosso, e come risposta alla tua domanda, no devi solo occuparti degli interi.
Kevin Cruijssen,

1
Suggerirei un caso di prova in cui contiene un'equazione corretta --. Per esempio 1991 = 2, -/3 = 3. (Molte lingue lo confondono con l'operatore in
declino

1
Il problema è che l'aggiunta di uno spazio 91 19se la soluzione è presente 9--9e nessuno spazio 9119se la soluzione 9229richiede la conoscenza della soluzione durante la creazione dei casi di test. Se ciò fosse consentito, potrei semplicemente aggiungere uno spazio solo prima dei caratteri scambiati e la soluzione potrebbe essere immediatamente derivata dal test case.
nwellnhof,

1
È la valutazione da sinistra a destra, o di *e /prima +e binari -?
aschepler,

Risposte:


5

Perl 6 , 132 113 byte

Grazie a Jo King per -19 byte.

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

Provalo online!

L'input è una stringa di equazioni separata da virgole e una stringa di risultati separati da virgola (spero che sia OK). L'output è una stringa contenente i due pulsanti scambiati.

Gestisce correttamente --. Prodotto potrebbe falsi positivi per ---, ++, **, o //, ma non ho potuto venire con un banco di prova.


Non devi gestire ---; ++; **; //; o altre cose come *+ecc. L'unica doppia non cifra adiacente che dovrai supportare è --. Inoltre, se comprendo correttamente il codice, non sarà necessario .subst('-','- ', poiché -5--15è consentito inserire il test case con uno spazio. Non sei il primo ad aggiungere codice per aggiungere questo spazio a livello di codice, quindi lo specificherò più chiaramente nella descrizione della sfida.
Kevin Cruijssen,

2
@KevinCruijssen Potrei dover gestire cose del genere **perché hanno un significato come espressioni Perl 6 e potrebbero causare falsi positivi. 1992 = 1potrebbe essere 1**2 = 1o 1//2 = 1, per esempio. Il substè per i casi in cui l'equazione corretta contiene --, ad esempio, il nuovo banco di prova è stato aggiunto.
nwellnhof,

La tua risposta è attualmente quella con il minor numero di byte, quindi per ora la accetterò. Se qualcuno trova qualcosa di più corto, il controllo potrebbe spostarsi di nuovo.
Kevin Cruijssen,


11

JavaScript (ES7), 159 158 byte

Modifica: nuova versione per rispettare le regole aggiornate relative a --
1 byte salvato grazie a @Shaggy

Accetta input nella sintassi del curry in (e)(r)cui e è l'array di equazioni e r è l'array dei risultati previsti. Restituisce una matrice di caratteri.

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

Casi test

Formattato e commentato

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

1
Penso che puoi salvare un byte evaling try / catch: codepen.io/anon/pen/rzRrLp .
Shaggy,

@Shaggy Ah sì, bello. Grazie!
Arnauld,

Sembra che questo potrebbe funzionare per 139 byte.
Shaggy,

Sì, ho appena eseguito una suite di test completa e l'ho notato.
Shaggy,

Non funziona per 1991 = 2. La soluzione dovrebbe essere 1--1 = 2con 9e -scambiata.
nwellnhof,

4

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

  • Da 199 byte a 193 byte grazie a Mr. Xcode
  • Da 193 byte a 173 byte grazie 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

Provalo online!



@ Mr.Xcoder grazie per l'osservazione, lo sto
risolvendo

1
@ Mr.Xcoder ecco la versione corretta
mdahmoune,



4

Oracle SQL e PL / SQL, 458 byte

L'input può essere in qualsiasi formato ragionevole. [...] un elenco con equazioni e un altro elenco con i risultati corretti.

Compilare la funzione PL / SQL (210 byte):

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;

Esegui SQL (248 byte):

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

Dopo aver creato una tabella Tcon i dati di test:

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

Produzione:

V V_1
- ---
2 *
* 2

Versione precedente :

Presupposto un input di stringa come '123 = 3':

Stessa funzione PL / SQL e SQL (322 byte):

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

Dopo aver creato una tabella Tcon i dati di test:

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;

Produzione:

V V_1
- ---
2 *
* 2

Aggiornamento - Test :

SQL Fiddle

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

Query 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

Risultati :

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

Query 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

Risultati :

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

Query 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

Risultati :

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

Query 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

Risultati :

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

Query 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

Risultati :

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

Query 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

Risultati :

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

Non è necessario ||REPLACE(x,'--','- -')||, il formato di input / output è flessibile, quindi è possibile immettere -5--15come -5- -15se lo si desidera. Inoltre, quale sarebbe il modo più semplice per me per verificare che tutti i casi di test funzionino, specialmente l'ultimo? Un collegamento TIO è in qualche modo possibile?
Kevin Cruijssen,

Oppure viene ||REPLACE(x,'--','- -')||utilizzato per un'equazione corretta attesa, come l'ultimo caso di test che ho aggiunto?
Kevin Cruijssen,

1
@KevinCruijssen --inizia un commento in SQL, quindi o i casi di test devono essere formulati in modo che --non si verifichino mai nell'equazione (sostituendoli con - -) o abbia bisogno di una codifica difensiva per militare per questo.
MT0,

Quindi per l'ultimo caso di test 13116/3 = -1dovrebbe essere scritto come 131 16/3 = -1rimuovere quella chiamata a REPLACE.
MT0,

Ah ok, quindi la sostituzione viene effettivamente utilizzata per le equazioni corrette attese. Grazie per aver aggiunto il violino SQL, +1 da me.
Kevin Cruijssen,

2

Powershell, 222 209 192 byte

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

Test script e spiegazione:

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

Produzione:

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

0

05AB1E , 21 byte

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

Inserire come due elenchi, prima le equazioni e la seconda i risultati. Output come un elenco filtrato di coppie con entrambe le rotazioni (cioè [["2","*"],["*","2"]]).

Provalo online o verifica tutti i casi di test . (NOTA: utilizza la versione legacy di 05AB1E nel TIO, perché .Eè disabilitata nella versione più recente su TIO. Per questo ïmotivo, viene aggiunto un ulteriore (cast in numero intero), perché nella versione legacy di 05AB1E 1.0e gli 1elenchi interni non erano uguali .)

Spiegazione:

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"]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.