Differenza di tre numeri interi di input

30

Implementa una funzione diff che accetta come input tre numeri interi x, ye z. Dovrebbe restituire se sottrarre uno di questi numeri da un altro dà il terzo.

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

Non è necessario assegnare un nome alla funzione, è possibile implementare metodi di input predefiniti, gli esempi sopra riportati non sono una linea guida rigorosa.

code-golf  arithmetic 
— Mir
fonte
5
Questa è una sfida ragionevole, ma non è necessario limitarla a Python o alle funzioni. In generale, tali restrizioni sono disapprovate perché limitano la partecipazione. Inoltre, dovresti includere alcuni casi di test.
— xnor
Ehi, l'ho risolto un po '. Spero che questo sia sufficiente!
— Mir
2
Sembra migliore! Consiglio vivamente di consentire i metodi di input predefiniti , in particolare i programmi, perché alcune lingue non hanno funzioni. E, consentendo alle funzioni di avere un altro nome o nessun nome.
— xnor
Il primo e l'ultimo paragrafo sono ora in conflitto, quindi solo per ricontrollare: dobbiamo scrivere una funzione o i programmi completi vanno bene?
— Sp3000,
i programmi completi vanno bene, voglio imporre il minor numero di restrizioni possibile tranne per il fatto che vengono seguiti i metodi di input predefiniti. ef gli esempi di python3 sono ordinati!
— Mir

Risposte:

14

Gelatina , 5 3 byte

Grazie a @ Sp3000 per aver salvato due byte!

Code, utilizza quasi lo stesso algoritmo della grande risposta di @ xnor :

SfḤ

Spiegazione:

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

Questo dà []come falsità e qualsiasi altra cosa come verità.

Provalo online!

— Adnan
fonte
51

Python 3, 21 byte

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

Se due numeri si aggiungono all'altro, la somma di tutti e tre sarà il doppio dell'altro numero, quindi metà della somma sarà un elemento dell'elenco. Python 3 è necessario per evitare la divisione dei piani, a meno che i numeri non siano indicati come 3.0piuttosto che come 3.

— XNOR
fonte
7

ES6, 31 byte

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

Aggiungi 5 byte se devi nominare la funzione diff.

Modifica: salvato 2 byte grazie a @Alex L.

— Neil
fonte
È possibile salvare due byte sostituendo ||con |(credo)
— HyperNeutrino il
@AlexL. Ah giusto, ero troppo stanco di dover restituire i booleani.
— Neil,
Anche con |valori booleani, restituisce un valore booleano se e solo se entrambi i valori sono booleani. Quindi true | false == true, ma 3 | 5 == 7. Lo stesso vale &&e &. L'unica differenza tra |e ||quando si tratta di booleani: |prenderà il primo valore e il secondo valore e troverà l' OR di quei due. ||prenderà il primo valore; se è vero, restituisce true, altrimenti, restituisce il secondo valore.
— HyperNeutrino,
@AlexL. true | falsevaluta 1 in JavaScript (che è vero, ma non booleano).
— Neil,
Oh. Mi dispiace, non uso davvero JS. Uso principalmente Java, da cui ho ottenuto queste informazioni. ;)
— HyperNeutrino,
4

APL, 8 5 byte

+/∊+⍨

Questo è un treno di funzioni monadico che accetta un array e restituisce un valore booleano (0/1 in APL). Utilizza lo stesso algoritmo della risposta Python 3 di xnor .

Spiegazione:

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

Provalo online

Salvato 3 byte grazie a Dennis!

— Alex A.
fonte
4

JavaScript ES6, 38 34 33 byte

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

Funzione anonima molto semplice e prende in prestito dalla risposta di Python. Accetta input xcome un array; ritorna trueo false. Byte rasati a Molarmanful e jrich

Un programma a 38 byte, prendendo ogni numero come argomento:

(a,b,c)=>[a,b,c].some(t=>t==(a+b+c)/2)
— Conor O'Brien
fonte
Prova x=>x.some(a=>a==eval(x.join`+`)/2), che consente di risparmiare 4 byte.
— Mama Fun Roll,
@ ӍѲꝆΛҐӍΛПҒЦꝆ Grazie! Bel trucco.
— Conor O'Brien,
x=>x.some(a=>2*a==x[0]+x[1]+x[2])sembra funzionare.
— jrich
@jrich Grazie! Bel trucco!
— Conor O'Brien,
3

Oracle SQL 11.2, 49 byte

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

Riscrivi la soluzione di @xnor, complimenti a lui.

— Jeto
fonte
3

J, 6 byte

+/e.+:

Da provare con J.js .

Come funziona

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

DUP , 31 caratteri / 39 byte

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

Try it here!

La mia prima presentazione DUP di sempre! Unicode è la tua ostrica.

È una funzione anonima / lambda. Uso:

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

Spiegazione

[                               {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
fonte
Non credo sia così che funziona una codifica ...
— Conor O'Brien,
øha il punto di codice 248, quindi è un byte se codificato come ISO 8859-1.
— Dennis,
1
... che va bene finché l'interprete può effettivamente lavorare con un file sorgente codificato ISO 8859-1.
— Martin Ender,
@ MartinBüttner Non credo sia possibile testarlo.
— 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
fonte
3

Perl 6, 20 19 byte

Ho due funzioni uguali nel conteggio dei byte, quindi inserirò entrambe. Apprezzo qualsiasi solletico la tua fantasia.

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

Utilizzo: assegnare uno a una variabile da cui è possibile chiamarlo.
EDIT: Grazie @ b2gills per la riduzione dei byte

— Tasti di scelta rapida
fonte
{@_∋@_.sum div 2}e {@_∋+~(@_.sum/2)}sono entrambi più brevi
— Brad Gilbert b2gills
Oh, grazie, dimentico sempre che puoi chiamare sum come metodo dotty
— Tasti di scelta rapida
Cosa fa ∋?
— Utente 121238386
"∋" è l'operatore infix 'contiene', che dice che la sinistra contiene la destra. È la sorella dell'op "∈" elemento che dice che la sinistra è un elemento della destra. Sono entrambi set ops e perl 6 in realtà supporta anche molti altri! docs.perl6.org/language/…
— Tasti di scelta rapida
3

Java 8 (funzione lambda), 29 byte

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

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

Le soluzioni Java per il golf del codice sono in genere brevi solo quando il programma non deve essere un programma completamente funzionale. (* tosse tosse * dichiarazione di classe, metodo principale)

— HyperNeutrino
fonte
2

Pyth, 6 byte

/Q/sQ2

Provalo online!

Si aspetta input come un elenco di numeri interi. Emette 0 se non è possibile creare alcun numero sottraendo gli altri due e> 0 se almeno uno può.

Spiegazione:

Stesso algoritmo della risposta di @xnor

/ Q / SQ2

   sQ # Somma tutti gli elementi nell'elenco
  / 2 # Dividi la somma per 2
/ Q # Count Occorrenze del numero sopra nell'elenco
— Denker
fonte
2

05AB1E , non competitivo

4 byte , non competitivi a causa di una cosa stupida. Codice:

DO;¢

Usando 0 come falsy e> 0 come verità. Utilizza la codifica CP-1252.

— Adnan
fonte
Qual è la cosa "stupida" che rende questo non competitivo?
— Kyle Kanos,
@KyleKanos Ho già scritto in Info.txt che ;dimezza la parte superiore dello stack. Ma indovina un po ', non l'ho mai implementato -_-.
— Adnan,
1
Ah. Posso vedere come lo farebbe
— Kyle Kanos
2

Kona 16 caratteri

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

Prende un vettore dalla pila, li somma, li divide per 2 e determina se è nel vettore. Restituisce 1 come verità e 0 come falsità.

Chiamato via

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

jq, 17 caratteri

(Ancora un'altra riscrittura della risposta di Python 3 di xnor. Le votazioni dovrebbero andare a quella.)

contains([add/2])

Input: matrice di 3 numeri interi.

Esecuzione di esempio:

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

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

Test online:

jq, 18 caratteri

(Codice di 17 caratteri + opzione della riga di comando di 1 carattere.)

contains([add/2])

Input: elenco di 3 numeri interi.

Esecuzione di esempio:

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

bash-4.3$ jq -s 'contains([add/2])' <<< '2 3 -5'
false
— uomo al lavoro
fonte
2

MATL , 5 byte

Utilizzando l'ottimo approccio di @ xnor :

s2/Gm

Provalo 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

Approccio a forza bruta, 12 byte :

Y@TT-1h*!s~a

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

CJam, 10 12 byte

l~:d_:+2/&

2 byte rimossi grazie a @ MartinBüttner.

Questo visualizza un numero come risultato veritiero e nessun output come risultato falsa.

Provalo qui

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
fonte
2

Scherzi a parte, 6 byte

,;䫡u

Emette 0 se falso e un numero intero positivo altrimenti.

— Mego
fonte
2

Mathematica, 20 19 byte

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

Funziona in modo simile alla maggior parte delle altre risposte.

— LegionMammal978
fonte
Che ne dici MemberQ[2{##},+##]&? (e hai dimenticato il conteggio dei byte)
— Martin Ender,
2

Haskell, 20 byte

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

Utilizzando la soluzione di xnor.

— Basile-henry
fonte
Dal momento (/)che non funziona per numeri interi e la sfida richiede numeri interi, non sono sicuro che questa sia in realtà una soluzione valida.
— Zeta,
Non l'ho visto. La conversione del tipo dovrebbe far parte del codice? In questo modo: (\l->sum l/2`elem`l).map fromIntegere può essere utilizzato in questo modo: ((\l->sum l/2`elem`l).map fromInteger) ([2,3,5] :: [Integer]). Immagino che ciò che mi ha colpito è stato xnor menzionare l'uso di Python 3, quindi l'input non doveva essere 3.0 invece di 3. Ho pensato che il tipo di input non fosse specificato, proprio come erano state scritte ...
— basile- Henry,
Se il tipo è davvero un problema, non dovrebbe essere più un problema il fatto che sto prendendo un elenco come input?
— basile-henry,
Buon punto. Chiederei a OP di questo. Ma dato che tutte le altre risposte usano anche un elenco, suppongo sia OK (inoltre, ora capisco perché la tua funzione non ha digitato check quando si usano le tuple).
— Zeta,
Sì, se l'input fosse una tupla anziché un elenco sumné elemfunzionerebbe, probabilmente avrei dovuto specificare che era un elenco ma poiché questa risposta è letteralmente ciò che xnor ha inviato (in Haskell) non pensavo fosse necessario. :)
— basile-henry
2

Perl, 24 + 4 = 28 byte

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

Richiede -paXl'esecuzione di flag, stampa 1come True e niente come False:

-X disabilita tutti gli avvisi. 

$ perl -paXe'$^+=$_/2 for@F;$_=$^~~@F' <<< '5 3 7'
$ perl -paXe'$^+=$_/2 for@F;$_=$^~~@F' <<< '5 3 8'
1
— andlrc
fonte
Ispirando uno. Ispirato a questo: $_=eval(y/ /+/r)/2~~@F(utilizza le stesse opzioni della riga di comando).
— arte
@manatwork Modo interessante da usare tr:)
— andlrc
Potresti lasciarlo -Xfuori specificando una versione di Perl [5.10 .. 5.18). (Smart match è stato introdotto in 5.10 e gli avvisi sperimentali sono stati introdotti in 5.18. Qualsiasi versione tra questi due funzionerà bene con ~~senza -X.)
— manatwork
1

Jolf, 6 byte

Provalo qui!

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

Questa è la fantastica soluzione di xnor al problema, ma in Jolf.

— Conor O'Brien
fonte
1

Piloni , 8

Ancora un'altra implementazione dell'algoritmo di xnor. 

i:As2A/_

Come funziona:

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
fonte
1

SpecBAS - 36 byte

Usa la formula xnors

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

genera 1 se vero e 0 se falso

— Brian
fonte
1

05AB1E , 6 5 byte

;Oм_O

-1 byte creando una porta dell'algoritmo Python 3 di @xnor .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Sono abbastanza sicuro che м_Opuò essere abbreviato, ma non sono sicuro di quale comando (i) devo usare per questo ..

— Kevin Cruijssen
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.