Implémentez une fonction diff qui prend en entrée trois entiers x, y et z. Il devrait renvoyer si la soustraction d'un de ces nombres d'un autre donne le troisième.

Test cases:
diff(5, 3, 2) yields True because 5 - 3 = 2
diff(2, 3, 5) yields True because 5 - 3 = 2
diff(2, 5, 3) yields True because 5 - 3 = 2
diff(-2, 3, 5) yields True because 3 - 5 is -2
diff(-5, -3, -2) # -5 - -2 is -3
diff(2, 3, -5) yields False
diff(10, 6, 4) yields True because 10 - 6 = 4
diff(10, 6, 3) yields False

Vous n'avez pas à nommer la fonction, vous pouvez implémenter des méthodes d'entrée par défaut, les exemples ci-dessus ne sont pas des directives strictes.

Gelée , 5 3 octets

Merci à @ Sp3000 pour avoir économisé deux octets!

Code, utilise à peu près le même algorithme que la grande réponse de @ xnor :

SfḤ

Explication:

S     # Sum of the argument list
  Ḥ   # Double the list
 f    # Filter, remove everything that isn't equal to the sum of the list

Cela donne []autant de fausseté, et tout ce qui est aussi vrai.

Essayez-le en ligne!

Python 3, 21 octets

lambda*l:sum(l)/2in l

Si deux nombres s'ajoutent à l'autre, la somme des trois sera le double de cet autre nombre, donc la moitié de la somme sera un élément de la liste. Python 3 est nécessaire pour éviter la division du sol, à moins que les nombres ne soient donnés comme 3.0plutôt que 3.

ES6, 31 octets

(a,b,c)=>a+b==c|b+c==a|c+a==b

Ajoutez 5 octets si vous devez nommer la fonction diff.

Edit: sauvé 2 octets grâce à @Alex L.

APL, 8 5 octets

+/∊+⍨

Il s'agit d'un train de fonctions monadiques qui accepte un tableau et renvoie un booléen (0/1 en APL). Il utilise le même algorithme que Python 3 de xnor réponse .

Explication:

   +⍨  ⍝ Double the input (+⍨x is the same as x+x)
  ∊    ⍝ Test the membership of
+/     ⍝ The sum of the input

Essayez-le en ligne

Enregistré 3 octets grâce à Dennis!

JavaScript ES6, 38 34 33 octets

x=>x.some(a=>2*a==x[0]+x[1]+x[2])

Fonction anonyme très simple, et emprunte à la réponse Python. Prend l'entrée xcomme un tableau; renvoie trueou false. Octets rasés à Molarmanful et jrich

Un programme de 38 octets, prenant chaque nombre en argument:

(a,b,c)=>[a,b,c].some(t=>t==(a+b+c)/2)

Oracle SQL 11.2, 49 octets

SELECT 1 FROM DUAL WHERE(:1+:2+:3)/2IN(:1,:2,:3);

Réécriture de la solution @xnor, bravo à lui.

J, 6 octets

+/e.+:

Essayez avec J.js .

Comment ça marche

+/e.+:    Monadic verb. Argument: A
    +:    Double the elements of A.
+/        Compute the sum of the elements of A.
  e.      Test for membership.

DUP , 31 caractères / 39 octets

[2ø2ø2ø++2/\%3ø^=3ø2ø=3ø3ø=||.]

Try it here!

Ma première soumission DUP jamais! Unicode est votre huître.

C'est une fonction anonyme / lambda. Usage:

5 3 2[2ø2ø2ø++2/\%3ø^=3ø2ø=3ø3ø=||.]!

Explication

[                               {start lambda}
 2ø2ø2ø                         {duplicate 3 inputnums}
       ++                       {push sum(3 popped stack items)}
         2/\%                   {push (popped stack item)/2}
             3ø^=3ø2ø=3ø3ø=     {for all 3 inputs, -1 if inputnum=sum/2; else 0}
                           ||   {check if any of the 3 resulting values are truthy}
                             .  {output top of stack (boolean value)}
                              ] {end lambda}

Java 7, 81

boolean d(int[]a){int s=0,t=1;for(int b:a)s+=b;for(int b:a)t*=2*b-s;return t==0;}

Perl 6, 20 19 octets

J'ai deux fonctions égales en nombre d'octets, donc je vais mettre les deux. Appréciez ce qui chatouille votre fantaisie.

{@_∋@_.sum div 2}
{@_∋+~(@_.sum/2)}

Utilisation: attribuez l'une ou l'autre à une variable à partir de laquelle vous pouvez l'appeler.
EDIT: Merci @ b2gills pour la réduction d'octets

Java 8 (fonction lambda), 29 octets

// Lambda Signature: (int, int, int) -> boolean

(a,b,c)->a+b==c|a+c==b|b+c==a

Les solutions de golf en code Java ne sont généralement courtes que lorsque le programme ne doit pas être un programme entièrement fonctionnel. (* toux toux * déclaration de classe, méthode principale)

Pyth, 6 octets

/Q/sQ2

Essayez-le en ligne!

Attend l'entrée comme une liste d'entiers. Affiche 0 si aucun nombre ne peut être construit en soustrayant les deux autres et> 0 si au moins un peut.

Explication:

Même algorithme que la réponse de @xnor

/ Q / sQ2

   sQ # Additionne tous les éléments de la liste
  / 2 # Divisez la somme par 2
/ Q # Count Nombre d'occurrences du nombre ci-dessus dans la liste

05AB1E , non concurrent

4 octets , non concurrents à cause d'une chose stupide. Code:

DO;¢

Utiliser 0 comme faux et> 0 comme vrai. Utilise l'encodage CP-1252.

Kona 16 caractères

{((+/x)%2)_in x}

Prend un vecteur de la pile, les additionne, divise par 2 et détermine s'il est dans le vecteur. Renvoie 1 comme véridique et 0 comme falsey.

Appelé via

> {((+/x)%2)_in x} [(2;3;5)]
1
> {((+/x)%2)_in x} [(2;3;4)]
0

jq, 17 caractères

(Encore une autre réécriture de xnor de » Python 3 réponse . Upvotes devrait aller à celui - là.)

contains([add/2])

Entrée: tableau de 3 entiers.

Exemple d'exécution:

bash-4.3$ jq 'contains([add/2])' <<< '[5, 3, 2]'
true

bash-4.3$ jq 'contains([add/2])' <<< '[2, 3, -5]'
false

Test en ligne:

• [5, 3, 2]
• [2, 3, -5]

jq, 18 caractères

(Code de 17 caractères + option de ligne de commande de 1 caractère.)

contains([add/2])

Entrée: liste de 3 entiers.

Exemple d'exécution:

bash-4.3$ jq -s 'contains([add/2])' <<< '5 3 2'
true

bash-4.3$ jq -s 'contains([add/2])' <<< '2 3 -5'
false

MATL , 5 octets

Utiliser la grande approche de @ xnor :

s2/Gm

Essayez-le en ligne!

s    % implicitly input array of three numbers. Compute their sum
2/   % divide by 2
G    % push input again
m    % ismember function: true if sum divided by 2 equals some element of the input

Approche par force brute, 12 octets :

Y@TT-1h*!s~a

Essayez-le en ligne!

Y@       % input array of three numbers. Matrix with all
         % permutations, each one on a different row
TT-1h    % vector [1,1,-1]
*        % multiply with broadcast
!s       % transpose, sum of each column (former row)
~a       % true if any value is 0

𝔼𝕊𝕄𝕚𝕟, 7 caractères / 9 octets

ï⒮≔⨭ï/2

Try it here (Firefox only).

Meh. Je trouve toujours de meilleures façons. C'est juste l'algorithme génial de @ xnor.

CJam, 10 12 octets

l~:d_:+2/&

2 octets supprimés grâce à @ MartinBüttner.

Cela affiche un nombre comme résultat véridique et aucune sortie comme résultat falsifié.

Essayez-le ici

l~     e# read line and evaluate. Pushes the array
:d     e# convert array to double
_      e# duplicate
:+     e# fold addition on the array. Computes sum of the array
2/     e# divide sum by 2
&      e# setwise and (intersection)

Sérieusement, 6 octets

,;䫡u

Affiche 0 si faux et un entier positif sinon.

Mathematica, 20 19 octets

MemberQ[2{##},+##]&

Fonctionne de manière similaire à la plupart des autres réponses.

Haskell, 20 octets

(\l->sum l/2`elem`l)

Utilisation de la solution de xnor.

Perl, 24 + 4 = 28 octets

$^+=$_/2 for@F;$_=$^~~@F

Requiert des -paXdrapeaux pour fonctionner, imprime1 en Vrai et rien en Faux:

-X désactive tous les avertissements.

$ perl -paXe'$^+=$_/2 for@F;$_=$^~~@F' <<< '5 3 7'
$ perl -paXe'$^+=$_/2 for@F;$_=$^~~@F' <<< '5 3 8'
1

Jolf, 6 octets

Essayez-le ici!

 hx½ux
_hx    the input array
   ½ux  has half the sum of the array

C'est la solution géniale de xnor au problème, mais dans Jolf.

Pylônes , 8

Encore une autre implémentation de l'algorithme de xnor.

i:As2A/_

Comment ça marche:

i    # Get command line input.
:A   # Initialize a constant A.
  s  # Set A to the sum of the stack.
2    # Push 2 to the stack.
A    # Push A to the stack.
/    # Divide A/2
_    # Check if the top of the stack is in the previous elements.
     # Print the stack on quit.

SpecBAS - 36 octets

Utilise la formule xnors

1 INPUT a,b,c: ?(a+b+c)/2 IN [a,b,c]

renvoie 1 si vrai et 0 si faux

05AB1E , 6 5 octets

;Oм_O

-1 octet en créant un port de l' algorithme Python 3 de @xnor .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

·        # Halve every item in the input-array
         #  i.e. [10,6,4] → [5.0,3.0,2.0]
 O       # Sum this array
         #  i.e. [5.0,3.0,2.0] → 10.0
  м_O    # Output 1 if the input-array contain this sum, 0 otherwise
         #  i.e. [10,6,4] and 10.0 → 1

Je suis sûr que cela м_Opeut être raccourci, mais je ne sais pas quelle (s) commande (s) je dois utiliser pour cela ..

R , 23 octets

sum(x<-scan())%in%(2*x)

Essayez-le en ligne!

Port sans vergogne de la réponse de xnor .