Aidez-moi! Ma calculatrice fonctionne mal!


28

introduction

Ma calculatrice se comporte bizarrement. Parfois, lorsque je tape un, 8il affiche un 2. Et parfois, lorsque je tape un, 6il affiche un +. Certains boutons sont mélangés!
Quelqu'un pourrait-il m'aider à déterminer lequel?

Défi:

Entrée: Liste des équations incorrectes , avec des résultats corrects .

Sortie: Les deux boutons qui sont échangés.

Par exemple:
Une entrée peut être:

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

Pour lesquels les résultats attendus sont: 2et *.

Pourquoi? Parce que TOUTES les équations seraient correctes si nous échangeons les 2 et les *:

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

Règles du défi:

  • L'entrée peut être dans n'importe quel format raisonnable. Peut être une chaîne unique avec un espace délimité; une liste de chaînes ou un tableau; une liste avec des équations et une autre liste avec les résultats corrects. Ton appel. Veuillez indiquer le format d'entrée que vous avez utilisé!
    REMARQUE: cela signifie également que vous êtes autorisé à saisir le scénario de test en -5--15tant que -5- -15ou -5 - -15. Cependant, un nombre résultant --doit être entré sans espaces ou avec un espace entre chaque chiffre. Ainsi, le cas de test 9119peut être entré comme 9119ou 9 1 1 9(la raison 91 19n'est pas autorisée parce que vous pouvez ensuite être guidé par l'espace de recherche - -). Les espaces sont donc (quelque peu) facultatifs et autorisés.
  • Le format de sortie peut également être dans n'importe quel format raisonnable. Peut être deux caractères; une seule chaîne de deux caractères; une liste de chaînes contenant les deux caractères. Ton appel. Encore une fois, veuillez indiquer le format de sortie que vous avez utilisé!
  • Vous êtes autorisé à utiliser 14 sorties distinctes qui correspondent à 0123456789+-*/. Donc, vous êtes même autorisé à produire deux entiers distincts si vous le souhaitez (encore une fois, veuillez spécifier le mappage que vous avez utilisé, le cas échéant).
  • Vous n'avez qu'à prendre en charge les entiers. Il n'y aura donc pas de cas de test comme 1/8=0.125ou 1/8=0.
  • Opérandes arithmétiques que vous devrez prendre en charge: addition ( +); soustraction ( -); multiplication ( *ou ×ou ·); division ( /ou ÷). (REMARQUE: les caractères entre parenthèses ne sont ajoutés qu'à titre de clarification.)
  • Vous devrez prendre en charge les nombres négatifs. Cela signifie -peut être interprété dans l'équation à la fois comme un opérande mathématique ou un indicateur négatif.
  • Vous pouvez supposer que les équations incorrectes données et les équations supposées correctes sont toujours valides (il n'y aura donc pas de choses comme 4-/2ou 9+-+8par exemple).
  • Les équations d'entrée incorrectes peuvent contenir une division par 0, mais les équations corrigées et attendues ne contiendront jamais de division par 0.
  • Les équations d'entrée incorrectes peuvent déjà être correctes même si vous permutez les boutons voulus.
  • Une équation d'entrée donnée peut être sans importance pour les boutons à échanger (comme les équations 4+4=8et 9/3=3, avec les boutons échangés 2et *).
  • Vous pouvez supposer qu'il n'y aura toujours qu'un seul échange possible qui peut être effectué avec les cas de test donnés.
  • Les deux boutons à permuter seront toujours présents dans au moins une des équations incorrectes.

Règles générales:

  • C'est le , donc la réponse la plus courte en octets l'emporte.
    Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
  • Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
  • Les failles par défaut sont interdites.
  • Si possible, veuillez ajouter un lien avec un test pour votre code.
  • Veuillez également ajouter une explication si nécessaire.

Cas de 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
"vraie division" signifie que nous devons supporter des flotteurs?
Erik the Outgolfer le

@EriktheOutgolfer Oups .. Copié cela à partir d'un défi arithmétique précédent. Supprimé, et comme réponse à votre question, non, vous n'avez qu'à traiter avec des entiers.
Kevin Cruijssen

1
Je suggérerais un cas de test où une équation correcte contient --. Par exemple 1991 = 2, -/3 = 3. (De nombreuses langues confondent cela avec l'opérateur de décrémentation.)
nwellnhof

1
Le problème est que l'ajout d'un espace 91 19si la solution est 9--9et pas d'espace 9119si la solution est 9229nécessite des connaissances sur la solution lors de la création des cas de test. Si cela était autorisé, je pourrais simplement ajouter un espace uniquement avant les caractères échangés et la solution pourrait être immédiatement dérivée du scénario de test.
nwellnhof

1
L'évaluation est - gauche à droite, ou *et /avant +et binaire -?
aschepler

Réponses:


5

Perl 6 , 132 113 octets

Merci à Jo King pour -19 octets.

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

Essayez-le en ligne!

L'entrée est une chaîne d'équations séparée par des virgules et une chaîne de résultats séparée par des virgules (espérons que cela est OK). La sortie est une chaîne contenant les deux boutons échangés.

Gère correctement --. Produit Might faux positifs pour ---, ++, **ou //, mais je ne pouvais pas venir avec un test.


Vous n'avez pas à gérer ---; ++; **; //; ou d'autres choses comme *+etc. Le seul double chiffre non adjacent que vous devrez prendre en charge est --. De plus, si je comprends bien votre code, vous n'en aurez pas besoin .subst('-','- ', car la saisie du scénario de test -5--15avec un espace est autorisée. Vous n'êtes pas le premier à ajouter du code pour ajouter cet espace par programmation, je vais donc le spécifier plus clairement dans la description du défi.
Kevin Cruijssen

2
@KevinCruijssen Je pourrais avoir à gérer des choses comme **parce qu'elles ont une signification en tant qu'expressions Perl 6 et peuvent provoquer des faux positifs. 1992 = 1pourrait être 1**2 = 1ou 1//2 = 1, par exemple. C'est substpour les cas où l'équation correcte contient --, par exemple le nouveau cas de test que vous avez ajouté.
nwellnhof

Votre réponse est actuellement celle qui contient le moins d'octets, donc je l'accepterai pour l'instant. Si quelqu'un propose quelque chose de plus court, le chèque peut à nouveau changer.
Kevin Cruijssen


11

JavaScript (ES7), 159158 octets

Edit: nouvelle version pour se conformer aux règles mises à jour concernant --
Saved 1 byte grâce à @Shaggy

Prend une entrée dans la syntaxe de curry (e)(r)e est le tableau des équations et r est le tableau des résultats attendus. Renvoie un tableau de caractères.

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

Cas de test

Formaté et commenté

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
Je pense que vous pouvez enregistrer un octet en utilisanteval le try / catch: codepen.io/anon/pen/rzRrLp .
Shaggy

@Shaggy Ah oui, gentil. Merci!
Arnauld

Il semble que cela puisse fonctionner pour 139 octets.
Shaggy

Ouais, je viens de lancer une suite de tests complète et j'ai repéré ça.
Shaggy

Ne fonctionne pas pour 1991 = 2. La solution doit être 1--1 = 2avec 9et -échangée.
nwellnhof

4

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

  • De 199 octets à 193 octets grâce à Mr. Xcode
  • De 193 octets à 173 octets grâce à 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

Essayez-le en ligne!



@ Mr.Xcoder merci pour la remarque, je le
corrige

1
@ Mr.Xcoder voici la version corrigée
mdahmoune



4

Oracle SQL et PL / SQL, 458 octets

L'entrée peut être dans n'importe quel format raisonnable. [...] une liste avec des équations et une autre liste avec les résultats corrects.

Compilez la fonction PL / SQL (210 octets):

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;

Exécutez le SQL (248 octets):

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

Après avoir créé un tableau Tavec les données de 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

Sortie:

V V_1
- ---
2 *
* 2

Version précédente :

Supposons une entrée de chaîne comme '123 = 3':

Même fonction PL / SQL et SQL (322 octets):

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

Après avoir créé un tableau Tavec les données de 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;

Sortie:

V V_1
- ---
2 *
* 2

Mise à jour - Test :

SQL Fiddle

Configuration du schéma 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
/

Requête 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

Résultats :

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

Requête 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

Résultats :

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

Requête 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

Résultats :

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

Requête 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

Résultats :

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

Requête 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

Résultats :

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

Requête 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

Résultats :

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

Pas besoin de ||REPLACE(x,'--','- -')||, le format d'entrée / sortie est flexible, vous êtes donc autorisé à entrer -5--15comme -5- -15si vous le vouliez. De plus, quelle serait la façon la plus simple pour moi de vérifier que tous les cas de test fonctionnent, en particulier le dernier? Une liaison TIO est-elle possible d'une manière ou d'une autre?
Kevin Cruijssen

Ou est-ce ||REPLACE(x,'--','- -')||utilisé pour une équation correcte attendue, comme le dernier cas de test que j'ai ajouté?
Kevin Cruijssen

1
@KevinCruijssen --commence un commentaire en SQL, donc soit les cas de test doivent être formulés de manière à ce que cela --ne se produise jamais dans l'équation (en le remplaçant par - -), soit il a besoin d'un codage défensif pour militer pour cela.
MT0

Donc, pour le dernier cas de test, 13116/3 = -1il faudrait écrire 131 16/3 = -1pour supprimer cet appel à REPLACE.
MT0

Ah ok, donc le remplacement est en effet utilisé pour les équations correctes attendues. Merci d'avoir ajouté le violon SQL, +1 de moi.
Kevin Cruijssen du

2

Powershell, 222 209 192 octets

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

Script de test et explication:

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

Sortie:

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 octets

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

Saisissez deux listes, les équations en premier et les résultats en deuxième. Sortie sous forme de liste filtrée de paires avec les deux rotations (c. [["2","*"],["*","2"]]-à-d.).

Essayez-le en ligne ou vérifiez tous les cas de test . (REMARQUE: utilise la version héritée de 05AB1E dans le TIO, car elle .Eest désactivée dans la version la plus récente sur TIO. Pour cette raison, une version supplémentaire ï(transtypée en entier) est ajoutée, car dans la version héritée de 05AB1E 1.0et les 1listes internes n'étaient pas égales .)

Explication:

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"]
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.