Implemente uma função diff que tome como entrada três números inteiros x, ye z. Ele deve retornar se subtrair um desses números de outro fornece o terceiro.

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

Você não precisa nomear a função; pode implementar métodos de entrada padrão; os exemplos acima não são uma diretriz estrita.

Geléia , 5 3 bytes

Obrigado ao @ Sp3000 por salvar dois bytes!

Code, usa o mesmo algoritmo da ótima resposta do @ xnor :

SfḤ

Explicação:

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

Isso dá []como falso, e qualquer outra coisa como verdade.

Experimente online!

Python 3, 21 bytes

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

Se dois números forem adicionados ao outro, a soma dos três será o dobro desse outro número; portanto, metade da soma será um elemento da lista. O Python 3 é necessário para evitar a divisão do piso, a menos que os números sejam dados como 3.0antes 3.

ES6, 31 bytes

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

Adicione 5 bytes se precisar nomear a função diff.

Editar: salvou 2 bytes graças a @Alex L.

APL, 8 5 bytes

+/∊+⍨

Este é um trem de função monádica que aceita uma matriz e retorna um booleano (0/1 em APL). Ele usa o mesmo algoritmo da resposta Python 3 do xnor .

Explicação:

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

Experimente online

Economizou 3 bytes graças a Dennis!

JavaScript ES6, 38 34 33 bytes

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

Função anônima muito simples e empresta a resposta do Python. Recebe entrada xcomo uma matriz; retorna trueou false. Bytes raspados para Molarmanful e jrich

Um programa de 38 bytes, considerando cada número como argumento:

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

Oracle SQL 11.2, 49 bytes

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

Reescreva a solução @xnor, parabéns a ele.

J, 6 bytes

+/e.+:

Experimente-o com J.js .

Como funciona

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

DUP , 31 caracteres / 39 bytes

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

Try it here!

Minha primeira submissão ao DUP! Unicode é sua ostra.

É uma função anônima / lambda. Uso:

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

Explicação

[                               {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 bytes

Eu tenho duas funções iguais na contagem de bytes, então eu vou colocar as duas. Aprecie o que lhe agrada.

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

Uso: atribua um a uma variável a partir da qual você pode chamá-lo.
EDIT: Obrigado @ b2gills pela redução de bytes

Java 8 (função lambda), 29 bytes

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

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

As soluções de golfe em código Java geralmente são curtas quando o programa não precisa ser um programa totalmente funcional. (* tosse * declaração de classe, método principal)

Pitão, 6 bytes

/Q/sQ2

Experimente online!

Espera entrada como uma lista de números inteiros. Produz 0 se nenhum número puder ser construído subtraindo os outros dois e> 0 se pelo menos um puder.

Explicação:

Mesmo algoritmo que a resposta de @xnor

/ Q / sQ2

   sQ # Soma todos os elementos da lista
  / 2 # Divida a soma por 2
/ Q # Count Ocorrências do número acima na lista

05AB1E , não concorrente

4 bytes , não concorrentes por causa de uma coisa estúpida. Código:

DO;¢

Usando 0 como falso e> 0 como verdade. Usa a codificação CP-1252.

Kona 16 chars

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

Pega um vetor da pilha, soma-os, divide por 2 e determina se está no vetor. Retorna 1 como verdade e 0 como falsey.

Chamado via

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

jq, 17 caracteres

(No entanto, outro reescrever xnor 's Python 3 resposta . Upvotes deve ir para aquele.)

contains([add/2])

Entrada: matriz de 3 números inteiros.

Exemplo de execução:

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

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

Teste on-line:

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

jq, 18 caracteres

(Código de 17 caracteres + opção de linha de comando de 1 caractere.)

contains([add/2])

Entrada: lista de 3 números inteiros.

Exemplo de execução:

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 bytes

Usando a ótima abordagem do @ xnor :

s2/Gm

Experimente online!

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

Abordagem de força bruta, 12 bytes :

Y@TT-1h*!s~a

Experimente online!

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 caracteres / 9 bytes

ï⒮≔⨭ï/2

Try it here (Firefox only).

Meh. Ainda estou encontrando maneiras melhores. É apenas o incrível algoritmo do @ xnor.

CJam, 10 12 bytes

l~:d_:+2/&

2 bytes removidos graças a @ MartinBüttner.

Isso exibe um número como resultado confiável e nenhuma saída como resultado falso.

Experimente aqui

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ério, 6 bytes

,;䫡u

Emite 0 se falso e um número inteiro positivo em contrário.

Mathematica, 20 19 bytes

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

Funciona de maneira semelhante à maioria das outras respostas.

Haskell, 20 bytes

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

Usando a solução do xnor.

Perl, 24 + 4 = 28 bytes

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

Requer -paXsinalizadores para executar, imprime 1como Verdadeiro e nada como Falso:

-X desativa todos os avisos.

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

Jolf, 6 bytes

Experimente aqui!

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

Esta é a incrível solução do xnor para o problema, mas em Jolf.

Postes , 8

Mais uma implementação do algoritmo do xnor.

i:As2A/_

Como funciona:

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 bytes

Usa a fórmula xnors

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

gera 1 se verdadeiro e 0 se falso

05AB1E , 6 5 bytes

;Oм_O

-1 byte, criando uma porta do algoritmo Python 3 do @xnor .

Experimente online ou verifique todos os casos de teste .

Explicação:

·        # 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

Tenho certeza de que м_Opode ser reduzido, mas não tenho certeza de quais comandos devo usar para isso.

R , 23 bytes

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

Experimente online!

Porta vergonhosa da resposta do xnor .