Diferença de três números inteiros de entrada


30

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.


5
Este é um desafio razoável, mas não há necessidade de restringi-lo ao Python ou funções. Em geral, essas restrições são desaprovadas porque limitam a participação. Além disso, você deve incluir alguns casos de teste.
xnor

Ei, eu arrumei um pouco. Espero que isso seja suficiente!
Mir

2
Parece melhor! Eu ainda recomendo permitir os métodos de entrada padrão , em programas específicos, porque alguns idiomas não têm funções. E, permitindo que as funções tenham outro nome ou nenhum nome.
Xnor

O primeiro e o último parágrafos agora estão em conflito, portanto, apenas para checar novamente - precisamos escrever uma função ou programas completos estão corretos?
Sp3000 07/02

programas completos são bons, quero impor o mínimo de restrições possível, exceto que os métodos de entrada padrão são seguidos. ef os exemplos python3 são legais!
Mir

Respostas:



51

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.


7

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.


Você pode salvar dois bytes, substituindo ||com |(eu acho)
HyperNeutrino

@AlexL. Ah, certo, eu estava muito ansiosa por ter que devolver os booleanos.
911 Neil

Mesmo com booleanos, |retorna um booleano se e somente se ambos os valores forem booleanos. Então true | false == true, mas 3 | 5 == 7. O mesmo se aplica &&e &. A única diferença entre |e ||quando se trata de booleanos: pegará |o primeiro valor e o segundo valor e encontrará o OR desses dois. ||receberá o primeiro valor; se for verdade, retorne true, caso contrário, retorne o segundo valor.
21416 HyperNeutrino

@AlexL. true | falseé avaliado como 1 em JavaScript (que é verdadeiro, mas não booleano).
911 Neil

Oh. Desculpe, eu realmente não uso JS. Eu uso principalmente o Java, de onde obtive essas informações. ;)
HyperNeutrino

4

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!


4

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)

Tente x=>x.some(a=>a==eval(x.join`+`)/2), que economiza 4 bytes.
Mama Fun Roll

@ Obrigado! Bom truque.
Conor O'Brien

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

@jrich Obrigado! Bom truque!
Conor O'Brien

3

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.


3

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.

3

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}

Eu não acho que é assim que funciona um que codificam ...
Conor O'Brien

øpossui o ponto de código 248, portanto, é um byte se codificado como ISO 8859-1.
Dennis

1
... o que é bom, desde que o intérprete possa realmente trabalhar com um arquivo de origem codificado ISO 8859-1.
Martin Ender

@ MartinBüttner Acho que não é possível testar isso.
Mama Fun Roll

3

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

3

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


{@_∋@_.sum div 2}e {@_∋+~(@_.sum/2)}são ambos curto
Brad Gilbert b2gills

Oh, obrigado, eu sempre esqueço que você pode chamar soma como um método dotty
Teclas de atalho

O que faz?
usar o seguinte comando

"∋" é o operador infixo 'contém', que diz que a esquerda contém a direita. É a irmã do "∈" 'elemento' op que diz que a esquerda é um elemento da direita. Ambos são set ops e o perl 6 também suporta muitos outros! docs.perl6.org/language/…
Teclas de atalho

3

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)


2

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

2

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.


Qual é a coisa "estúpida" que torna isso não competitivo?
Kyle Kanos

@KyleKanos Eu já escrevi em Info.txt que ;divide pela metade a parte superior da pilha. Mas adivinhem, eu nunca o implementei -_-.
Adnan

1
Ah Eu posso ver como é que faria isso
Kyle Kanos

2

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

2

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:

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

2

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


2

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)

2

Sério, 6 bytes

,;䫡u

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


2

Mathematica, 20 19 bytes

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

Funciona de maneira semelhante à maioria das outras respostas.


Que tal MemberQ[2{##},+##]&? (e tenha esquecido da sua contagem de bytes)
Martin Ender

2

Haskell, 20 bytes

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

Usando a solução do xnor.


Como (/)não funciona para números inteiros e o desafio pede números inteiros, não tenho certeza se essa é realmente uma solução válida.
Zeta

Eu não vi isso. A conversão de tipo deve fazer parte do código? Como esta: (\l->sum l/2`elem`l).map fromIntegere ele pode ser usado como este: ((\l->sum l/2`elem`l).map fromInteger) ([2,3,5] :: [Integer]). Eu acho que o que me impressionou foi xnor mencionar o uso do python 3 para que a entrada não tivesse que ser 3.0 em vez de 3. Pensei que o tipo de entrada não fosse especificado, do jeito que foram escritos ...
basile- henry

Se o tipo é realmente um problema, o fato de eu estar recebendo uma lista como entrada não deve ser mais um problema?
basile-henry

Bom ponto. Eu perguntaria à OP sobre isso. Mas, como todas as outras respostas também usam uma lista, acho que está OK (também, agora entendi por que sua função não digitou check ao usar tuplas).
Zeta

Sim, se a entrada fosse uma tupla, em vez de uma lista, sumnem elemfuncionaria, provavelmente eu deveria ter especificado que era uma lista, mas como essa resposta é literalmente o que o xnor enviou (em Haskell), não achei que fosse necessário. :)
basile-henry

2

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

Um inspirador. Inspirou isso: $_=eval(y/ /+/r)/2~~@F(usa as mesmas opções de linha de comando).
Manatwork

@manatwork maneira interessante usar tr:)
andlrc

Você pode deixar isso de -Xfora especificando uma versão do Perl [5.10 .. 5.18). (Smart jogo foi introduzido em 5,10 e advertências experimentais foram introduzidos em 5,18 Qualquer versão entre os dois vai funcionar bem com. ~~Sem -X.)
manatwork

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.


1

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.

1

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


1

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.


Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.