Input: due numeri interi. Preferibilmente numeri interi decimali, ma possono essere utilizzate altre forme di numeri. Questi possono essere dati al codice in input standard, come argomenti per il programma o la funzione o come elenco.

Uscita: la loro somma. Utilizzare lo stesso formato per gli interi di output degli interi di input. Ad esempio, l'input 5 16porterebbe all'output 21.

Restrizioni: nessuna scappatoia standard per favore. Questo è code-golf , la risposta nella quantità più bassa di byte vince.

Note: Questo dovrebbe essere abbastanza banale, tuttavia sono interessato a vedere come può essere implementato. La risposta può essere un programma completo o una funzione, ma si prega di identificare quale sia.

Casi test:

1 2 -> 3
14 15 -> 29
7 9 -> 16
-1 8 -> 7
8 -9 -> -1
-8 -9 -> -17

O come CSV:

a,b,c
1,2,3
14,15,29
7,9,16
-1,8,7
8,-9,-1
-8,-9,-17

Classifica

var QUESTION_ID=84260,OVERRIDE_USER=8478;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Gelatina , 1 byte

+

Provalo online!

Funziona anche in 05AB1E, attualmente, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicit, J, Julia, K, kdb +, Keg, Ly, MATL, Pyke, Deorst e Q.

Minecraft 1.10, 221 personaggi (non concorrenti)

Vedi, questo è ciò di cui dobbiamo occuparci quando creiamo mappe di Minecraft.

A parte: non c'è modo di accettare un input di stringa in Minecraft, quindi sto barando un po 'facendoti inserire i numeri nel programma stesso. (È in qualche modo giustificabile perché alcune mappe, come Minecraft Bingo di Lorgon111, richiedono di copiare e incollare i comandi nella chat per inserire un numero.)

Grazie mille per il filtro MCEdit di Block Labels .

scoreboard objectives add a dummy
scoreboard players set m a 6
scoreboard players set n a 8
scoreboard players operation r a += m a
scoreboard players operation r a += n a
tellraw @a {"score":{"name":"r","objective":"a"}}

Non competere a causa di difficoltà nell'input, e non ho idea di come contare i byte in questa cosa (il sistema blytes è difettoso per i blocchi di comando).

Calcolo lambda binario , 4.125 byte

Input e output come numeri Church .

00000000 01011111 01100101 11101101 0

Nel calcolo lambda , è λ m . λ n . λ f . λ x . m f ( n f x ).

Indice di De Bruijn : λ λ λ λ 4 2 (3 2 1)

Il calcolo lambda è un modo conciso di descrivere una mappatura (funzione).

Ad esempio, questa attività può essere scritta come λ x . λ y . x + y

La cosa da notare è che questa non è una lambda (funzione) che accetta due argomenti. Questo è in realtà un lambda nidificato. Tuttavia, si comporta come un lambda che accetta due argomenti, quindi può essere descritto in modo informale come tale. Ogni lambda prende formalmente solo un argomento.

Ad esempio, se applichiamo questo lambda a 3 e 4:

(λ x . λ y . x + y ) 3 4 ≡ (λ y . 3 + y ) 4 ≡ 3 + 4 = 7

Quindi, la prima lambda in realtà restituisce un'altra lambda.

I numeri di chiesa sono un modo per eliminare i segni extra, lasciando solo simboli e variabili lambda.

Ogni numero nel sistema della Chiesa è in realtà un lambda che specifica quante volte la funzione viene applicata a un oggetto.

Lascia che la funzione sia f e che l'elemento sia x .

Quindi, il numero 1 corrisponderebbe a λ f . λ x . f x , che significa applicare f a x esattamente una volta.

Il numero 3, ad esempio, sarebbe λ f . λ x . f ( f ( f x )), che significa applicare f a x esattamente tre volte.

Pertanto, per aggiungere due numeri di Church (diciamo, m e n ) insieme, è lo stesso che applicare f a x , m + n volte.

Possiamo osservare che questo equivale a prima applicare f a x , n volte, quindi applicare f all'elemento risultante m volte.

Ad esempio, 2 significherebbe f(f(x))e 3 significherebbe f(f(f(x))), quindi 2 + 3 sarebbe f(f(f(f(f(x))))).

Per applicare f a x , n volte, abbiamo n f x .

È possibile visualizzare m e n come funzioni che accettano due argomenti, in modo informale.

Quindi, applichiamo di nuovo f a questo elemento risultante, m volte: m f ( n f x ).

Quindi, aggiungiamo nuovamente la piastra della caldaia per ottenere λ m . λ n . λ f . λ x . m f ( n f x ).

Ora, dobbiamo convertirlo in indice De Bruijn .

Innanzitutto, contiamo la "distanza relativa" tra ciascuna variabile e la dichiarazione lambda. Ad esempio, la m avrebbe una distanza di 4, perché è dichiarata 4 lambdas "fa". Allo stesso modo, la n avrebbe una distanza di 3, la f avrebbe una distanza di 2 e la x avrebbe una distanza di 1.

Quindi, lo scriviamo come questa forma intermedia: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Quindi, rimuoviamo le dichiarazioni delle variabili, lasciandoci con: λ λ λ λ 4 2 (3 2 1)

Ora, lo convertiamo in calcolo lambda binario .

Le regole sono:

• λ diventa 00.
• m n (raggruppamento) diventa 01 m n.
• i numeri i diventano 1 i volte + 0, ad esempio 4 diventa 11110.

λ λ λ λ 4 2 (3 2 1)

≡ λ λ λ λ 11110 110( 1110 110 10)

≡ λ λ λ λ 11110 110 0101 111011010

≡ λ λ λ λ 0101 111101100101111011010

≡ 00 00 00 00 0101 111101100101 111011010

≡ 000000000101111101100101111011010

Lisp comune, 15 byte

(+(read)(read))

Stack Cats , 8 + 4 = 12 byte

]_:]_!<X

Corri con le -mnbandiere. Provalo online!

Giocare a golf in Stack Cats è altamente controintuitivo, quindi questo programma sopra è stato trovato con alcuni giorni di forzatura bruta. Per fare un confronto, una soluzione più intuitiva scritta dall'uomo usando il *(...)>modello è più lunga di due byte

*(>-_:[:)>

con le -lnbandiere invece (vedi il fondo di questo post per una spiegazione).

Spiegazione

Ecco un primer su Stack Cats:

• Stack Cats è un linguaggio esoterico reversibile in cui lo specchio di uno snippet annulla l'effetto dello snippet originale. I programmi devono anche essere immagini speculari di se stesso - necessariamente, ciò significa che i programmi di lunghezza pari sono o no-op o loop infiniti, e tutti i programmi di terminazione non banali hanno una lunghezza dispari (e sono essenzialmente una coniugazione dell'operatore centrale).
• Poiché metà del programma è sempre implicita, una metà può essere esclusa con il flag -mo -l. Qui -mviene utilizzato il flag, quindi il mezzo programma sopra si espande in realtà ]_:]_!<X>!_[:_[.
• Come suggerisce il nome, Stack Cats è basato su stack, con le pile che sono senza fondo con zero (cioè operazioni su uno stack altrimenti vuoto restituiscono 0). Stack Cats utilizza effettivamente un nastro di pile, ad esempio <e >sposta rispettivamente una pila a sinistra e una a destra.
• Gli zeri nella parte inferiore della pila vengono deglutiti / rimossi.
• Tutti gli input vengono inviati a uno stack di input iniziale, con il primo input in alto e un ulteriore -1 sotto l'ultimo input. L'output viene eseguito alla fine, utilizzando il contenuto dello stack corrente (con un -1 opzionale in fondo viene ignorato). -nindica I / O numerico.

Ed ecco una traccia del programma completo espanso ]_:]_!<X>!_[:_[:

    Initial state (* denotes current stack):
      ... [] [-1 b a]* [] [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [a]* [] ...
_   Reversible subtraction, performing [x y] -> [x x-y] (uses an implicit zero here)
      ... [] [-1 b] [-a]* [] ...
:   Swap top two
      ... [] [-1 b] [-a 0]* [] ...
]   Move one stack right, taking the top element with you
      ... [] [-1 b] [-a] []* ...
_   Reversible subtraction (0-0, so no-op here)
!   Bit flip top element, x -> -x-1
      ... [] [-1 b] [-a] [-1]* ...
<   Move one stack left
      ... [] [-1 b] [-a]* [-1] ...
X   Swap the stack to the left and right
      ... [] [-1] [-a]* [-1 b] ...
>   Move one stack right
      ... [] [-1] [-a] [-1 b]* ...
!   Bit flip
      ... [] [-1] [-a] [-1 -b-1]* ...
_   Reversible subtraction
      ... [] [-1] [-a] [-1 b]* ...
[   Move one stack left, taking the top element with you
      ... [] [-1] [-a b]* [-1] ...
:   Swap top two
      ... [] [-1] [b -a]* [-1] ...
_   Reversible subtraction
      ... [] [-1] [b a+b]* [-1] ...
[   Move one stack left, taking the top element with you
      ... [] [-1 a+b]* [b] [-1] ...

a+bviene quindi emesso, con la base -1 ignorata. Si noti che la parte più delicata di questa soluzione è che lo stack di output deve avere a -1nella parte inferiore, altrimenti uno stack di output di appena [-1]ignorerebbe la base -1 e uno stack di output [0]causerebbe la deglutizione dello zero di base (ma un output la pila di [2], per esempio, produrrebbe 2proprio bene).

Per divertimento, ecco l'elenco completo di soluzioni correlate della stessa lunghezza trovata (l'elenco potrebbe non essere completo):

]_:]^!<X
]_:]_!<X
]_:]!^<X
]_:!]^<X
[_:[^!>X
[_:[_!>X
[_:[!^>X
[_:![^>X

La *(>-_:[:)>soluzione è più lunga, ma è più intuitiva da scrivere poiché utilizza il *(...)>modello. Questo modello si espande <(...)*(...)>quando utilizzato con la -lbandiera, il che significa:

<       Move one stack left
(...)   Loop - enter if the top is positive and exit when the top is next positive again
        Since the stack to the left is initially empty, this is a no-op (top is 0)
*       XOR with 1 - top of stack is now 1
(...)   Another loop, this time actually run
>       Move one stack right

Pertanto, il *(...)>modello indica che il primo ciclo viene ignorato ma il secondo viene eseguito. Ciò consente una programmazione più semplice, poiché non dobbiamo preoccuparci degli effetti del loop nell'altra metà del programma.

In questo caso, l'interno del loop è:

>       Move one stack right, to the input stack
-       Negate top, [-1 b a] -> [-1 b -a]
_       Reversible subtraction, [-1 b -a] -> [-1 b a+b]
:       Swap top two, [-1 b a+b] -> [-1 a+b b]
[       Move one stack left, taking top of stack with you (removing the top b)
:       Swap top two, putting the 1 on this stack on top again

Il finale >nel modello ci riporta quindi allo stack di input, dove a+bviene emesso.

Brak-flak , 6 byte

({}{})

Provalo online!

Brak-flak è un linguaggio davvero interessante con due importanti restrizioni.

1. Gli unici caratteri validi sono le parentesi, ovvero uno di questi caratteri:

   (){}[]<>
   

2. Ogni singolo set di parentesi deve essere interamente abbinato, altrimenti il ​​programma non è valido.

Una serie di parentesi con nulla tra loro è chiamata "nilad". Un nilad crea un certo valore numerico e tutti questi nilad uno accanto all'altro vengono sommati. Una serie di parentesi con qualcosa tra loro è chiamata "monade". Una monade è una funzione che accetta un argomento numerico. Quindi vengono valutate le parentesi all'interno di una monade, e questo è l'argomento della monade. Ecco un esempio più concreto.

Il () nilad è uguale a 1. Quindi il seguente codice cervello-flak:

()()()

Viene valutato su 3. La () monade inserisce il valore al suo interno nello stack globale. Quindi il seguente

(()()())

spinge un 3. Il {}nilad fa apparire il valore in cima allo stack. Poiché vengono sempre aggiunti nilad consecutivi, una stringa di {}somma tutti gli elementi principali nello stack. Quindi il mio codice è essenzialmente:

push(pop() + pop())

Minecraft 1.10.x, 924 512 byte

Grazie a @ quat per ridurre il blytecount di 48 punti e il bytecount di 412.

Bene, quindi, ho preso alcune delle idee da questa risposta e ne ho realizzato una versione mia, tranne per il fatto che questa è in grado di accettare input non negativi. Una versione può essere trovata qui in formato blocco struttura.

(la nuova versione sembra piuttosto noiosa)

Comandi simili come l'altra risposta:

scoreboard objectives add a dummy
execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1
execute @e[type=Cow] ~ ~ ~ scoreboard players add n a 1
scoreboard players operation n a += m a
tellraw @a {"score":{"name":"n","objective":"a"}}

Per inserire numeri, genera un numero di mucche e maiali. Le mucche rappresenteranno il valore "n" e i suini rappresenteranno il valore "m". Il sistema a blocchi di comando ucciderà progressivamente mucche e maiali e assegnerà i valori secondo necessità.

Questa risposta presuppone che tu sia in un mondo senza mucche o maiali presenti in natura e che i valori memorizzati in "n" e "m" siano cancellati ad ogni corsa.

Retina , 42 byte

\d+
$*
T`1p`-_` |-1+
+`.\b.

^(-)?.*
$1$.&

Provalo online!

Spiegazione

Aggiungere numeri in unario è la cosa più semplice al mondo, ma una volta che si introducono numeri negativi, le cose diventano complicate ...

\d+
$*

Iniziamo convertendo i numeri in unari. Questo viene fatto abbinando ciascun numero con \d+e sostituendolo con $*. Questa è una funzione di sostituzione specifica per Retina. La sintassi completa è count$*charactere inserisce countcopie di character. Entrambi possono essere omessi laddove per countimpostazione predefinita $&(ovvero la corrispondenza stessa) e per characterimpostazione predefinita 1. Quindi per ogni input nne otteniamo nuno e abbiamo ancora potenziali segni meno all'interno, così come il separatore di spazio. Ad esempio input 8 -5fornisce:

11111111 -11111

Ora per gestire i numeri negativi è più facile usare una -1cifra separata . Useremo -per quello scopo.

T`1p`-_` |-1+

Questa fase fa due cose. Elimina lo spazio, i segni meno principali e trasforma la 1s dopo un segno meno in -se stessi. Questo viene fatto abbinando |-1+(cioè uno spazio o un numero negativo) ed eseguendo una traslitterazione su di esso. La traslitterazione va da 1pa -_, ma qui si pespande a tutti i caratteri ASCII stampabili e _significa eliminazione. Quindi 1in quelle partite si trasformano in se -i punti negativi e gli spazi vengono rimossi. Il nostro esempio ora appare così:

11111111-----

+`.\b.

Questa fase gestisce il caso in cui vi sia un numero positivo e uno negativo nell'input. In tal caso, ci saranno 1s e -s nella stringa e vogliamo che vengano annullati. Questo viene fatto abbinando due caratteri con un limite di parole tra loro (poiché 1s è considerato un carattere di parola e -non lo è) e sostituendo la corrispondenza con nulla. I +istruisce Retina farlo ripetutamente finché la corda smette di cambiare.

Ora ci rimangono solo 1 s o solo - s.

^(-)?.*
$1$.&

Per riconvertire questo in decimale, abbiniamo l'intero input, ma se possibile catturiamo un -in gruppo 1. 1Riscriviamo il gruppo (per anteporre un -numero negativo a) e quindi riscriviamo la durata della partita con $.&(anche una funzione di sostituzione specifica di Retina).

Domino , 38.000 byte o 37 tessere

Questo viene creato in Simulatore da tavolo . Ecco un video ed ecco il file . È un mezzo sommatore standard, composto da un andcancello per il 2^1valore del luogo e un xorcancello per il 2^0valore del luogo.

Dettagli

• I / O
  • Avvio : è incluso per chiarezza (non conteggiato per il totale) ed è ciò che 'chiama' o 'esegue' la funzione. Dovrebbe essere 'premuto' dopo che è stato immesso [Giallo] .
  • Ingresso A - Questo è incluso per chiarezza (non conteggiato per il totale) ed è 'premuto' per indicare a 1e non premuto per 0 [Verde] .
  • Ingresso B - Questo è incluso per chiarezza (non conteggiato per il totale) ed è 'premuto' per indicare a 1e non premuto per 0 [Blu] .
  • Output : viene conteggiato per il totale. Questi domino dichiarano la somma. La sinistra è 2^1e la destra è 2^0 [Nero] .
• urgente
  • Per dare input o avviare la catena, genera il marmo metallico
  • Impostare la forza di sollevamento su 100%
  • Solleva il marmo sopra il domino desiderato
  • Lascia cadere il marmo

Haskell, 3 byte

(+)

Le parentesi sono qui perché deve essere una funzione di prefisso. Ciò equivale a prendere una sezione della funzione +, ma non vengono applicati argomenti. Funziona anche su una vasta gamma di tipi, come vettori correttamente implementati, matrici, numeri complessi, galleggianti, doppi, razionali e, naturalmente, numeri interi.

Perché questo è Haskell, ecco come farlo a livello di tipo. Questo verrà fatto in fase di compilazione anziché in fase di esecuzione:

-- This *type* represents Zero
data Zero
-- This *type* represents any other number by saying what number it is a successor to.
-- For example: One is (Succ Zero) and Two is (Succ (Succ Zero))
data Succ a

-- a + b = c, if you have a and b, you can find c, and if you have a and c you can find b (This gives subtraction automatically!)
class Add a b c | a b -> c, a c -> b

-- 0 + n = n 
instance Add Zero n n
-- If (a + b = c) then ((a + 1) + b = (c + 1))
instance (Add a b c) => Add (Succ a) b (Succ c)

Codice adattato da Haskell Wiki

Mathematica, 4 2 byte

Tr

_{La croce 4 è ancora regolare 4 ...} Tr applicata a un elenco unidimensionale prende la somma degli elementi di detto elenco.

Shakespeare Programming Language , 155 152 byte

.
Ajax,.
Ford,.
Act I:.
Scene I:.
[Enter Ajax and Ford]
Ajax:
Listen to thy heart
Ford:
Listen to THY heart!You is sum you and I.Open thy heart
[Exeunt]

Ungolfed:

Summing Two Numbers in Verona.

Romeo, a numerical man.
Juliet, his lover and numerical counterpart.

Act I: In which Italian addition is performed.

Scene I: In which our two young lovers have a short chat.

[Enter Romeo and Juliet]

Romeo:
  Listen to thy heart.

Juliet:
  Listen to THY heart! Thou art the sum of thyself and I. Open thy heart.

[Exeunt]

Sto usando il compilatore SPL di drsam94 per compilare questo. Testare:

$ python splc.py sum.spl > sum.c
$ gcc sum.c -o sum.exe
$ echo -e "5\n16" | ./sum
21

Brachylog , 2 byte

+.

Si aspetta un elenco con i due numeri come input

In alternativa, se si desidera la risposta a STDOUT:

+w

dc, 2 byte

+f

Aggiunge i primi due elementi in pila (precedentemente presi da stdin), quindi scarica il contenuto della pila in stdout.

EDIT: A ulteriore considerazione, sembra che ci siano diversi modi in cui questo potrebbe essere implementato, a seconda del comportamento I / O desiderato.

+        # adds top two items and pushes on stack
+n       # adds top two and prints it, no newline, popping it from stack
+dn      # ditto, except leaves result on stack
??+      # takes two inputs from stdin before adding, leaving sum on stack

Suppongo che il modulo più completo per la somma sia questo:

??+p     # takes two inputs, adds, 'peeks'
         #  (prints top value with newline and leaves result on stack)

Aspettare! Due numeri possono essere presi sulla stessa linea, separati da uno spazio! Questo ci dà:

?+p

JavaScript (ES6), 9 byte

a=>b=>a+b

PHP, 20 byte

Sorprendentemente breve questa volta:

<?=array_sum($argv);

Viene eseguito dalla riga di comando, come:

$ php sum.php 1 2

Cheddar, 3 byte

(+)

Questa è una bella caratteristica di Cheddar chiamata "operatori funzionalizzati". Il merito di questa idea va a @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Ecco altri esempi di operatori funzionalizzati:

(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5

Python, 11 3 byte

sum

int.__add__

Un semplice operatore speciale.

Geometry Dash - 15 oggetti

Finalmente concluso.
15 oggetti non sono molti, ma è stato comunque un incubo farlo (soprattutto a causa dei numeri negativi).

Poiché dovrei inserire 15 immagini qui per come riprodurlo, ho appena caricato il livello. L'ID livello è 5216804. La descrizione spiega come eseguirlo e puoi copiarlo poiché è copiabile.

Spiegazione:

Il trigger in alto a sinistra (Instant Count 2) ha verificato se il primo addend era 0. In tal caso, ha verificato se il secondo addend era positivo o negativo. Se fosse positivo, trasferiva il valore dal secondo addend alla somma (stile BF, usando i loop) e se fosse negativo, farebbe la stessa cosa.

Il motivo per cui dobbiamo verificare se il secondo addend è positivo o negativo è che dovremmo sottrarre uno dal secondo addend e aggiungerne uno alla somma o aggiungerne uno al secondo addend e sottrarre rispettivamente uno dalla somma.

Se il primo addend non è zero, verifica se è positivo o negativo utilizzando il processo sopra. Dopo un'iterazione nel ciclo while, verifica se il primo addend è zero e, in caso affermativo, esegue il processo descritto all'inizio della spiegazione.

Poiché Geometry Dash è notevolmente simile a BF, è possibile ricavarne una soluzione BF.

MATL, 1 byte

s

Accetta una matrice di due numeri interi come input e li somma. Mentre il semplice programma di +funziona anche, quello è già stato mostrato per altre lingue.

Provalo online

Perl 5,10, 8 byte

I due numeri da aggiungere devono essere su 2 righe separate affinché questa funzioni:

say<>+<>

Prova questo qui.

Uno con input sulla stessa riga ( 14 + 1 byte per -a flag )

say$F[0]+$F[1]

Provalo qui!

Uno con input sulla stessa riga ( 19 + 1 byte per -a flag )

map{$s+=$_}@F;say$s

Prova questo qui.

Un altro, modificando il separatore predefinito dell'array ( 19 + 1 byte anche per -a flag )

$"="+";say eval"@F"

Prova questo qui!

Fuzzy Octo Guacamole , 1 byte

a

Una funzione che accetta input dalla parte superiore dello stack e genera spingendo nello stack.

Esempio in esecuzione nel REPL:

>>> 8 9 :
[8,9]
>>> a :
17

Lotto, 25 18 16 byte

@cmd/cset/a%1+%2

Modifica: salvato 7 9 byte usando il mio trucco da Alternating Sign Sequence .

PowerShell v2 +, 17 byte

$args-join'+'|iex

Accetta input come due argomenti della riga di comando separati, che vengono precompilati nell'array speciale $args. Formiamo una stringa con l' -joinoperatore concatenandoli insieme a a +nel mezzo, quindi reindirizziamo quella stringa Invoke-Expression(simile a eval).

Grazie a @DarthTwon per avermi ricordato che quando si ha a che fare con programmi così minimi, ci sono più metodi per prendere input tutti allo stesso conteggio byte.

$args[0]+$args[1]
param($a,$b)$a+$b

PowerShell è nulla se non flessibile.

> <> , 7 6 3 byte

+n;

Interprete online

Oppure provalo su TIO con il flag -v.

Provalo online

C, 35 byte

s(x,y){return y?s(x^y,(x&y)<<1):x;}

Quello che ho fatto qui è un'aggiunta definita senza l'uso di operatori booleani o aritmetici. Questo fa ricorsivamente x i bit di somma di 'xor', e y i bit di carry di 'e' fino a quando non c'è carry. Ecco la versione non golfata:

int sum(int x,int y){
    if(y==0){
        //anything plus 0 is itself
        return x;
    }
    //if it makes you happier imagine there's an else here
    int sumBits=x^y;
    int carryBits=(x&y)<<1;
    return sum(sumBits,carryBits);
}

MATLAB, 4 byte

1 byte rimosso grazie a @LeakyNun

@sum

Questa è una funzione anonima che accetta un array e fornisce la somma. Esempio di utilizzo:

>> f = @sum
f = 
    @sum
>> f([3 4])
ans =
     7

GoLScript , 1 byte (non competitivo)

K

Aggiunge i primi 2 numeri nello stack. Questo è tutto.

Ora come spingerli in pila, non ne ho idea. Non credo sia possibile .. tosse @ CᴏɴᴏʀO'Bʀɪᴇɴ tosse

Shakespeare Programming Language (SPL), 137 135 byte

Programma completo, giocato a golf:

.
A.
B.
Act I
Scene I
[Enter A and B]
A: Listen to your heart!
B: Listen to your heart! You are the sum of me and you. Open your heart! 

E una breve spiegazione:

----
.                                 <- Title, everything before the first 
                                     full stop is considered as the tittle and treated as a comment
----
A.                                <- Dramatis personae. Here are introduced the characters in the play.
                                     |Characters are treated as variables.   
B.                                <--
----
Act I                             <- Acts and scenes are used to divide a program into smaller
                                     chunks in order to be able to refer to them later.
                                     |
Scene I                           <--
----
[Enter A and B]                   <- Characters on stage in the current scene, which are the              
                                     variables the program will have access to.
----
A: Listen to your heart!          <- Line of code. All of them have the same structure
                                     Variable: code. In this case, the concrete sentence
                                    "Listen to your heart!" reads an input number and stores it
                                     on the character (variable) refered to.
B: Listen to your heart!          <- Same as above 
   You are the sum of me and you. <- Sum the values of itself and the caharacter (variable)
                                     refered to.
   Open your heart!               <- Output the value of the character (value) refered to.

In realtà non sono sicuro che questo sia il più breve possibile. Controlla la pagina ufficiale per maggiori informazioni.

Modifica 1: rimosso il :dopo Act Ie Scene Ipoiché sembra che tutto ciò che segue il numero romano venga ignorato, risparmiando così 2 byte.

codice macchina x86_32, 2 byte

08048540 <add7>:
 8048540:   01 c8                   add    %ecx,%eax

Supponendo che i due valori siano già nei registri ecx e eax, l'esecuzione dell'istruzione add aggiungerà i valori dei due registri e memorizzerà il risultato nel registro di destinazione.

Puoi vedere il programma completo scritto in C e inline assembly qui . Scrivere il wrapper in C rende più semplice fornire input ed eseguire test, ma la funzione di aggiunta effettiva può essere ridotta fino a questi due byte.