Entrada: dos enteros. Preferiblemente enteros decimales, pero se pueden usar otras formas de números. Estos pueden darse al código en la entrada estándar, como argumentos para el programa o función, o como una lista.

Salida: Su suma. Use el mismo formato para los enteros de salida que los enteros de entrada. Por ejemplo, la entrada 5 16conduciría a la salida 21.

Restricciones: No hay lagunas estándar, por favor. Este es el código de golf , la respuesta en la menor cantidad de bytes gana.

Notas: Esto debería ser bastante trivial, sin embargo, estoy interesado en ver cómo se puede implementar. La respuesta puede ser un programa completo o una función, pero identifique cuál es.

Casos de prueba:

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

O como CSV:

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

Tabla de clasificación

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

+

Pruébalo en línea!

También funciona en 05AB1E, Actually, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicit, J, Julia, K, kdb +, Keg, Ly, MATL, Pyke, Deorst y Q.

Minecraft 1.10, 221 caracteres (no competitivos)

Mira, esto es con lo que tenemos que lidiar cuando hacemos mapas de Minecraft.

Aparte: no hay forma de tomar una entrada de cadena en Minecraft, así que estoy engañando un poco al hacer que ingreses los números en el programa. (Es algo justificable porque bastantes mapas, como Minecraft Bingo de Lorgon111, requieren que copie y pegue comandos en el chat para ingresar un número).

Gracias abrightmoore por el filtro Block Labels MCEdit.

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

No compite debido a dificultades en la entrada, y no tengo idea de cómo contar bytes en esto (el sistema blytes tiene fallas para los bloques de comandos).

Cálculo binario lambda , 4.125 bytes

Entrada y salida como números de iglesia .

00000000 01011111 01100101 11101101 0

En el cálculo lambda , es λ m . λ n . λ f . λ x . m f ( n f x ).

Índice de Bruijn : λ λ λ λ 4 2 (3 2 1)

El cálculo de Lambda es una forma concisa de describir un mapeo (función).

Por ejemplo, esta tarea se puede escribir como λ x . λ y . x + y

Lo que hay que tener en cuenta es que esta no es una lambda (función) que toma dos argumentos. Esto es en realidad una lambda anidada. Sin embargo, se comporta como una lambda que toma dos argumentos, por lo que puede describirse informalmente como tal. Cada lambda formalmente solo toma un argumento.

Por ejemplo, si aplicamos este lambda a 3 y 4:

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

Entonces, la primera lambda en realidad devuelve otra lambda.

Los números de la iglesia son una forma de eliminar los signos adicionales, dejando solo los símbolos y variables lambda.

Cada número en el sistema de la Iglesia es en realidad una lambda que especifica cuántas veces se aplica la función a un elemento.

Deje que la función sea fy el elemento sea x .

Entonces, el número 1 correspondería a λ f . λ x . f x , lo que significa aplicar f a x exactamente una vez.

El número 3, por ejemplo, sería λ f . λ x . f ( f ( f x )), lo que significa aplicar f a x exactamente tres veces.

Por lo tanto, añadir dos números Church (digamos, m y n ) juntos, es lo mismo que aplicar f a x , m + n veces.

Podemos observar que esto es lo mismo que aplicar primero f a x , n veces, y luego aplicar f al elemento resultante m veces.

Por ejemplo, 2 significaría f(f(x))y 3 significaría f(f(f(x))), entonces 2 + 3 sería f(f(f(f(f(x))))).

Para aplicar f a x , n veces, tenemos n f x .

Puede ver m y n como funciones tomar dos argumentos, de manera informal.

Luego, aplicamos f nuevamente a este elemento resultante, m veces: m f ( n f x ).

Luego, volvemos a agregar el repetitivo para obtener λ m . λ n . λ f . λ x . m f ( n f x ).

Ahora, tenemos que convertirlo al índice De Bruijn .

En primer lugar, contamos la "distancia relativa" entre cada variable y la declaración lambda. Por ejemplo, la m tendría una distancia de 4, porque se declara 4 lambdas "ago". Del mismo modo, la n tendría una distancia de 3, la f tendría una distancia de 2 y la x tendría una distancia de 1.

Entonces, lo escribimos como esta forma intermedia: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Luego, eliminamos las declaraciones de variables, dejándonos con: λ λ λ λ 4 2 (3 2 1)

Ahora, lo convertimos en cálculo lambda binario .

Las reglas son:

• λ se convierte 00.
• m n (agrupación) se convierte en 01 m n.
• números i se convierte en 1 i multiplicado por + 0, por ejemplo, 4 se convierte en 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 común, 15 bytes

(+(read)(read))

Apilar gatos , 8 + 4 = 12 bytes

]_:]_!<X

Corre con las -mnbanderas. Pruébalo en línea!

Jugar al golf en Stack Cats es altamente contradictorio, por lo que este programa anterior se encontró con unos días de fuerza bruta. A modo de comparación, una solución más intuitiva escrita por humanos que usa la *(...)>plantilla es dos bytes más larga

*(>-_:[:)>

con las -lnbanderas en su lugar (vea la parte inferior de esta publicación para obtener una explicación).

Explicación

Aquí hay un manual sobre Stack Cats:

• Stack Cats es un lenguaje esotérico reversible donde el espejo de un fragmento deshace el efecto del fragmento original. Los programas también deben ser imágenes especulares de sí mismo; necesariamente, esto significa que los programas de longitud par son no-ops o bucles infinitos, y todos los programas de terminación no triviales son de longitud impar (y son esencialmente una conjugación del operador central).
• Dado que la mitad del programa siempre está implícito, la mitad se puede omitir con el indicador -mo -l. Aquí -mse usa la bandera, por lo que el medio programa anterior se expande realmente a ]_:]_!<X>!_[:_[.
• Como su nombre lo indica, Stack Cats está basado en la pila, con las pilas sin fondo con ceros (es decir, las operaciones en una pila vacía devuelven 0). Stack Cats en realidad usa una cinta de pilas, por ejemplo, <y >mueve una pila hacia la izquierda y una pila hacia la derecha respectivamente.
• Los ceros en la parte inferior de la pila se tragan / eliminan.
• Todas las entradas se envían a una pila de entrada inicial, con la primera entrada en la parte superior y un -1 adicional debajo de la última entrada. La salida se realiza al final, utilizando el contenido de la pila actual (con un -1 opcional en la parte inferior que se ignora). -ndenota E / S numérica.

Y aquí hay un rastro del programa completo expandido ]_:]_!<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+bluego se emite, con la base -1 ignorada. Tenga en cuenta que la parte más complicada de esta solución es que la pila de salida debe tener una -1en la parte inferior; de lo contrario, una pila de salida simplemente [-1]ignoraría la base -1, y una pila de salida [0]provocaría que se tragara la base cero (pero una salida pila de [2], por ejemplo, saldría 2bien).

Solo por diversión, aquí está la lista completa de soluciones relacionadas de la misma longitud encontrada (la lista puede no estar completa):

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

La *(>-_:[:)>solución es más larga, pero es más intuitiva de escribir ya que usa la *(...)>plantilla. Esta plantilla se expande <(...)*(...)>cuando se usa con la -lbandera, lo que 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

Como tal, la *(...)>plantilla significa que se omite el primer bucle pero se ejecuta el segundo. Esto permite que tenga lugar una programación más sencilla, ya que no tenemos que preocuparnos por los efectos del bucle en la otra mitad del programa.

En este caso, el interior del bucle es:

>       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

El final >en la plantilla luego nos mueve de regreso a la pila de entrada, donde a+bse emite.

Brain-flak , 6 bytes

({}{})

Pruébalo en línea!

Brain-flak es un lenguaje realmente interesante con dos restricciones importantes.

1. Los únicos caracteres válidos son corchetes, es decir, cualquiera de estos caracteres:

   (){}[]<>
   

2. Cada conjunto de paréntesis debe coincidir por completo, de lo contrario, el programa no es válido.

Un conjunto de paréntesis sin nada entre ellos se llama "nilad". Una nilad crea un cierto valor numérico, y se suman todas estas nilads una al lado de la otra. Un conjunto de paréntesis con algo entre ellos se llama "mónada". Una mónada es una función que toma un argumento numérico. Entonces se evalúan los corchetes dentro de una mónada, y ese es el argumento para la mónada. Aquí hay un ejemplo más concreto.

El () nilad es igual a 1. Entonces, el siguiente código de cerebro-flak:

()()()

Se evalúa como 3. La () mónada empuja el valor dentro de ella en la pila global. Entonces lo siguiente

(()()())

empuja un 3. El {}nilad muestra el valor en la parte superior de la pila. Dado que siempre se agregan nilads consecutivos, una cadena de {}sumas de todos los elementos superiores de la pila. Entonces mi código es esencialmente:

push(pop() + pop())

Minecraft 1.10.x, 924 512 bytes

Gracias a @ quat por reducir el blytecount en 48 puntos y el bytecount en 412.

Muy bien, entonces, tomé algunas de las ideas de esta respuesta e hice una versión propia, excepto que esta es capaz de aceptar aportes no negativos. Puede encontrar una versión aquí en formato de bloque de estructura.

(la nueva versión se ve un poco aburrida por cierto)

Comandos similares a la otra respuesta:

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

Para ingresar números, genera una cantidad de vacas y cerdos. Las vacas representarán el valor "n" y los cerdos representarán el valor "m". El sistema de bloques de comando matará progresivamente a las vacas y los cerdos y asignará valores según sea necesario.

Esta respuesta asume que usted está en un mundo sin vacas o cerdos naturales y que los valores almacenados en "n" y "m" se borran en cada corrida.

Retina , 42 bytes

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

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

Pruébalo en línea!

Explicación

Agregar números en unario es la cosa más fácil del mundo, pero una vez que introduce números negativos, las cosas se ponen complicadas ...

\d+
$*

Comenzamos por convertir los números a unarios. Esto se hace haciendo coincidir cada número con \d+y reemplazándolo por $*. Esta es una característica de sustitución específica de Retina. La sintaxis completa es count$*charactere inserta countcopias de character. Ambos pueden omitirse donde está countpredeterminado $&(es decir, la coincidencia misma) y characterpredeterminado 1. Entonces, para cada entrada nobtenemos nunos, y todavía tenemos signos negativos potenciales allí, así como el separador de espacio. Por ejemplo, la entrada 8 -5da:

11111111 -11111

Ahora, para tratar con números negativos, es más fácil usar un -1dígito separado . Lo usaremos -para ese propósito.

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

Esta etapa hace dos cosas. Se deshace del espacio, los signos negativos principales, y convierte los 1s después de un signo negativo en -sí mismos. Esto se hace combinando |-1+(es decir, un espacio o un número negativo) y realizando una transliteración en él. La transliteración va de 1pa -_, pero aquí, se pexpande a todos los caracteres ASCII imprimibles y _significa eliminar. Entonces, 1s en esos partidos se convierten en -sy desventajas y espacios se eliminan. Nuestro ejemplo ahora se ve así:

11111111-----

+`.\b.

Esta etapa maneja el caso donde hay un número positivo y uno negativo en la entrada. Si es así, habrá 1s y -s en la cadena y queremos que se cancelen. Esto se hace combinando dos caracteres con un límite de palabras entre ellos (ya que 1s se considera un carácter de palabra y -no lo es), y reemplazando la coincidencia con nada. El le +indica a Retina que haga esto repetidamente hasta que la cadena deje de cambiar.

Ahora nos quedan solo 1 so s o solo - s.

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

Para convertir esto de nuevo a decimal, hacemos coincidir toda la entrada, pero si es posible capturamos un -en grupo 1. 1Reescribimos el grupo (para anteponer a -a números negativos) y luego reescribimos la duración de la coincidencia con $.&(también una función de sustitución específica de Retina).

Dominó , 38,000 bytes o 37 fichas

Esto se crea en Tabletop Simulator . Aquí hay un video y aquí está el archivo . Es un medio sumador estándar, compuesto por una andpuerta para el 2^1valor posicional y una xorpuerta para el 2^0valor posicional.

Detalles

• I / O
  • Inicio : se incluye para mayor claridad (no se cuenta para el total) y es lo que "llama" o "ejecuta" la función. Debe "presionarse" después de que se ingrese la entrada [Amarillo] .
  • Entrada A : se incluye para mayor claridad (no se cuenta para el total) y se 'presiona' para indicar 1ay no se presiona para 0 [Verde] .
  • Entrada B : se incluye para mayor claridad (no se cuenta hacia el total) y se 'presiona' para indicar 1ay no se presiona para 0 [Azul] .
  • Salida : se cuenta en el total. Estas fichas de dominó declaran la suma. La izquierda es 2^1y la derecha es 2^0 [Negro] .
• Prensado
  • Para dar entrada o iniciar la cadena, genera la canica de metal
  • Establezca la fuerza de elevación en 100%
  • Levanta la canica por encima del dominó deseado
  • Deja caer la canica

Haskell, 3 bytes

(+)

Los paréntesis están aquí porque debe ser una función de prefijo. Esto es lo mismo que tomar una sección de la función +, pero no se aplican argumentos. También funciona en una amplia gama de tipos, como vectores, matrices, números complejos, flotantes, dobles, racionales y, por supuesto, enteros implementados correctamente.

Como se trata de Haskell, aquí se explica cómo hacerlo a nivel de tipo. Esto se hará en tiempo de compilación en lugar de tiempo de ejecución:

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

Código adaptado de Haskell Wiki

Mathematica, 4 2 bytes

Tr

_{Tachado 4 sigue siendo regular 4 ...} Tr aplicado a una lista unidimensional toma la suma de los elementos de dicha lista.

dc, 2 bytes

+f

Agrega los dos primeros elementos en la pila (previamente extraídos de stdin), luego volca el contenido de la pila stdout.

EDITAR: Tras una consideración adicional, parece que hay varias formas en que esto podría implementarse, dependiendo del comportamiento de E / S deseado.

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

Supongo que la forma más completa para la suma sería esta:

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

¡Espere! ¡Se pueden tomar dos números en la misma línea, separados por un espacio! Esto nos da:

?+p

Lenguaje de programación Shakespeare , 155 152 bytes

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

Sin golf:

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]

Estoy usando el compilador SPL de drsam94 para compilar esto. Probar:

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

Brachylog , 2 bytes

+.

Espera una lista con los dos números como entrada

Alternativamente, si quieres la respuesta a STDOUT:

+w

JavaScript (ES6), 9 bytes

a=>b=>a+b

PHP, 20 bytes

Sorprendentemente corto esta vez:

<?=array_sum($argv);

Se ejecuta desde la línea de comandos, como:

$ php sum.php 1 2

Cheddar, 3 bytes

(+)

Esta es una característica genial de Cheddar llamada "operadores funcionalizados". El crédito por esta idea va para @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Aquí hay más ejemplos de operadores funcionalizados:

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

Python, 11 3 bytes

sum

int.__add__

Un simple operador especial.

Geometry Dash - 15 objetos

Finalmente hecho.
15 objetos no son mucho, pero todavía fue una pesadilla hacer esto (especialmente debido a los números negativos).

Como tendría que insertar 15 imágenes aquí para ver cómo reproducir esto, acabo de subir el nivel. El ID de nivel es 5216804. La descripción le indica cómo ejecutarlo y puede copiarlo ya que es copiable.

Explicación:

El disparador superior izquierdo (Conteo instantáneo 2) verificó si el primer agregado fue 0. Si lo fue, luego verificó si el segundo fue positivo o negativo. Si fue positivo, transfirió el valor del segundo sumando a la suma (estilo BF, usando bucles) y si fuera negativo, haría lo mismo.

La razón por la que necesitamos verificar si el segundo suma es positivo o negativo es que tendríamos que restar uno del segundo sumando y agregar uno a la suma o sumar al segundo sumando y restar uno de la suma respectivamente.

Si el primer sumando no es cero, prueba si es positivo o negativo usando el proceso anterior. Después de una iteración en el ciclo while, prueba para ver si el primer sumando es cero y si lo es, realiza el proceso descrito al comienzo de la explicación.

Dado que Geometry Dash es notablemente similar a BF, podría hacer una solución BF a partir de esto.

MATL, 1 byte

s

Acepta una matriz de dos enteros como entrada y los suma. Si bien el programa simple de +también funciona, eso ya se ha mostrado para otros idiomas.

Pruébalo en línea

Perl 5.10, 8 bytes

Los dos números para agregar deben estar en 2 líneas separadas para que este funcione:

say<>+<>

Prueba este aquí.

Uno con entrada en la misma línea ( 14 + 1 bytes para -a marca )

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

Pruébalo aquí!

Uno con entrada en la misma línea ( 19 + 1 bytes para -a marca )

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

Prueba este aquí.

Otra, cambiando el separador predeterminado array ( 19 + 1 bytes para -a bandera así)

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

Prueba este aquí!

Fuzzy Octo Guacamole , 1 byte

a

Una función que toma entradas desde la parte superior de la pila y las salidas empujando a la pila.

Ejemplo que se ejecuta en REPL:

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

Lote, 25 18 16 bytes

@cmd/cset/a%1+%2

Editar: guardado 7 9 bytes usando mi truco de Alternating Sign Sequence .

PowerShell v2 +, 17 bytes

$args-join'+'|iex

Toma la entrada como dos argumentos de línea de comando separados, que se rellenan previamente en la matriz especial $args. Formamos una cadena con el -joinoperador al concatenarlos junto con un +en el medio, luego canalizamos esa cadena a Invoke-Expression(similar a eval).

Gracias a @DarthTwon por recordarme que cuando se trata de programas tan mínimos, existen múltiples métodos para tomar datos, todos al mismo número de bytes.

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

PowerShell no es nada si no es flexible.

> <> , 7 6 3 bytes

+n;

Intérprete en línea

O pruébelo en TIO con la bandera -v.

Pruébalo en línea

C, 35 bytes

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

Lo que he hecho aquí es la suma definida sin el uso de operadores booleanos o aritméticos. Esto hace recursivamente x los bits de suma por 'xor', y y los bits de acarreo por 'y' hasta que no haya carry. Aquí está la versión sin golf:

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 bytes

1 byte eliminado gracias a @LeakyNun

@sum

Esta es una función anónima que toma una matriz y da la suma. Ejemplo de uso:

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

GoLScript , 1 byte (no competitivo)

K

Agrega los 2 números superiores en la pila. Eso es.

Ahora cómo empujar ellos en la pila, no tengo idea. No creo que sea posible ... tos @ CᴏɴᴏʀO'Bʀɪᴇɴ tos

Lenguaje de programación de Shakespeare (SPL), 137 135 bytes

Programa completo, golfizado:

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

Y una breve explicación:

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

No estoy seguro de que sea lo más corto posible. Consulta la página oficial para más información.

Edición 1: se eliminó el :after Act Iy Scene Iparece que todo lo que está después del número romano se ignora, lo que ahorra 2 bytes.

Código de máquina x86_32, 2 bytes

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

Suponiendo que los dos valores ya están en los registros ecx y eax, la ejecución de la instrucción de agregar agregará los valores de los dos registros y almacenará el resultado en el registro de destino.

Puede ver el programa completo escrito en C y ensamblado en línea aquí . Escribir el contenedor en C hace que sea más fácil proporcionar entradas y hacer pruebas, pero la función de agregar real se puede reducir a estos dos bytes.