Différence de trois entiers d'entrée

30

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.

code-golf  arithmetic 
— Mir
source
5
C'est un défi raisonnable, mais il n'est pas nécessaire de le limiter à Python ou à des fonctions. En général, ces restrictions sont mal vues car elles limitent la participation. Vous devez également inclure certains cas de test.
— xnor
Hé je l'ai réparé un peu. J'espère que cela suffit!
— Mir
2
Regarde mieux! Je recommande toujours fortement d'autoriser les méthodes d'entrée par défaut , en particulier les programmes, car certaines langues n'ont pas de fonctions. Et, permettant aux fonctions d'avoir un autre nom ou aucun nom.
— xnor
Le premier et le dernier paragraphes sont maintenant en conflit, donc juste pour revérifier - devons-nous écrire une fonction ou les programmes complets sont-ils corrects?
— Sp3000
les programmes complets sont très bien, je veux imposer le moins de restrictions possible, sauf que les méthodes d'entrée par défaut sont suivies. ef les exemples de python3 sont soignés!
— Mir

Réponses:

14

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!

— Adnan
source
51

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.

— xnor
source
7

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.

— Neil
source
Vous pouvez économiser deux octets en remplaçant ||par |(je pense)
— HyperNeutrino
@AlexL. Ah oui, j'étais trop accroché à devoir retourner des booléens.
— Neil
Même avec des booléens, |renvoie un booléen si et seulement si les deux valeurs sont booléennes. Alors true | false == true, mais 3 | 5 == 7. La même chose s'applique &&et &. La seule différence entre |et ||quand il s'agit de booléens: |prendra la première valeur et la deuxième valeur et trouvera le OU de ces deux. ||prendra la première valeur; si c'est vrai, retournez true, sinon, retournez la deuxième valeur.
— HyperNeutrino
@AlexL. true | falseest évalué à 1 en JavaScript (ce qui est vrai, mais pas booléen).
— Neil
Oh. Désolé, je n'utilise pas vraiment JS. J'utilise principalement Java, d'où je tire ces informations. ;)
— HyperNeutrino
4

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!

— Alex A.
source
4

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)
— Conor O'Brien
source
Essayez x=>x.some(a=>a==eval(x.join`+`)/2), ce qui économise 4 octets.
— Mama Fun Roll
@ ӍѲꝆΛҐӍΛПҒЦꝆ Merci! Joli tour.
— Conor O'Brien
x=>x.some(a=>2*a==x[0]+x[1]+x[2])semble fonctionner.
— jrich
@jrich Merci! Joli tour!
— Conor O'Brien
3

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.

— Jeto
source
3

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.
— Dennis
source
3

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}
— Mama Fun Roll
source
Je ne pense pas que c'est comme ça qu'un encodage fonctionne ...
— Conor O'Brien
øa le point de code 248, il s'agit donc d'un octet s'il est codé ISO 8859-1.
— Dennis
1
... ce qui est bien tant que l'interpréteur peut réellement travailler avec un fichier source encodé ISO 8859-1.
— Martin Ender
@ MartinBüttner Je ne pense pas qu'il soit possible de tester cela.
— 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;}
— Marky Markov
source
3

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

— Raccourcis clavier
source
{@_∋@_.sum div 2}et {@_∋+~(@_.sum/2)}sont tous deux plus courts
— Brad Gilbert b2gills
Oh merci, j'oublie toujours que vous pouvez appeler sum comme une méthode dotty
— Hotkeys
Que fait ∋-il?
— User112638726
"∋" est l'opérateur d'infixe 'contains', qui dit que la gauche contient la droite. C'est la sœur de l'op "élément" "which" qui dit que la gauche est un élément de la droite. Ils sont tous les deux des opérations définies et Perl 6 en supporte également beaucoup d'autres! docs.perl6.org/language/…
— Raccourcis
3

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)

— HyperNeutrino
source
2

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
— Denker
source
2

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.

— Adnan
source
Quelle est la chose "stupide" qui rend cette non-concurrence?
— Kyle Kanos
@KyleKanos J'ai déjà écrit dans Info.txt qui ;divise par deux le haut de la pile. Mais devinez quoi, je ne l'ai jamais implémenté -_-.
— Adnan
1
Ah. Je peux voir comment cela se
— passerait
2

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
— Kyle Kanos
source
2

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:

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
— homme au travail
source
2

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
— Luis Mendo
source
2

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)
— Luis Mendo
source
2

Sérieusement, 6 octets

,;䫡u

Affiche 0 si faux et un entier positif sinon.

— Mego
source
2

Mathematica, 20 19 octets

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

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

— LegionMammal978
source
Et alors MemberQ[2{##},+##]&? (et vous avez oublié votre nombre d'octets)
— Martin Ender
2

Haskell, 20 octets

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

Utilisation de la solution de xnor.

— basile-henry
source
Comme (/)cela ne fonctionne pas pour les entiers et que le défi demande des entiers, je ne suis pas sûr que ce soit une solution valide.
— Zeta
Je n'ai pas vu ça. La conversion de type doit-elle faire partie du code? Comme ceci: (\l->sum l/2`elem`l).map fromIntegeret il peut être utilisé comme ceci: ((\l->sum l/2`elem`l).map fromInteger) ([2,3,5] :: [Integer]). Je suppose que ce qui m'a découragé était xnor mentionnant l'utilisation de python 3, donc l'entrée n'avait pas besoin d'être 3.0 au lieu de 3. Je pensais que le type d'entrée n'était pas spécifié, juste la façon dont ils étaient écrits ...
— basile- henry
Si le type est vraiment un problème, le fait que je prenne une liste en entrée ne devrait-il pas être plus un problème?
— basile-henry
Bon point. Je demanderais à OP à ce sujet. Mais étant donné que toutes les autres réponses utilisent également une liste, je suppose que c'est OK (aussi, maintenant je comprends pourquoi votre fonction n'a pas tapé check lors de l'utilisation de tuples).
— Zeta
Oui, si l'entrée était un tuple au lieu d'une liste, sumni elemne fonctionnerait, j'aurais probablement dû spécifier que c'était une liste mais comme cette réponse est littéralement ce que xnor a soumis (dans Haskell), je ne pensais pas que c'était nécessaire. :)
— basile-henry
2

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
— andlrc
source
Inspirant. Inspiré de ceci: $_=eval(y/ /+/r)/2~~@F(utilise les mêmes options de ligne de commande).
— manatwork
@manatwork Façon intéressante d'utiliser tr:)
— andlrc
Vous pouvez laisser cela de -Xcôté en spécifiant une version Perl [5.10 .. 5.18). (La correspondance intelligente a été introduite en 5.10 et des avertissements expérimentaux ont été introduits en 5.18. Toute version entre ces deux fonctionnera bien avec ~~sans -X.)
— manatwork
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.

— Conor O'Brien
source
1

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.
— Morgan Thrapp
source
1

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

— Brian
source
1

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 ..

— Kevin Cruijssen
source
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.