Entrada: dois números inteiros. De preferência números inteiros decimais, mas outras formas de números podem ser usadas. Eles podem ser fornecidos ao código na entrada padrão, como argumentos para o programa ou função ou como uma lista.

Saída: a soma deles. Use o mesmo formato para números inteiros de saída que números inteiros de entrada. Por exemplo, a entrada 5 16levaria à saída 21.

Restrições: Não há brechas padrão, por favor. Isso é código-golfe , responda na menor quantidade de bytes ganhos.

Notas: Isso deve ser bastante trivial, no entanto, estou interessado em ver como ele pode ser implementado. A resposta pode ser um programa completo ou uma função, mas identifique qual é.

Casos de teste:

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

Ou como CSV:

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

Entre os melhores

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>

Jelly , um byte

+

Experimente online!

Também funciona em 05AB1E, na verdade, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicit, J, Julia, K, kdb +, Keg, Ly, MATL, Pyke, Deorst e Q.

Minecraft 1.10, 221 caracteres (não concorrente)

Veja, é com isso que devemos lidar quando fazemos mapas do Minecraft.

Além: Não há como inserir uma string no Minecraft, por isso estou trapaceando um pouco ao fazer você inserir os números no próprio programa. (É um pouco justificável, porque alguns mapas, como o Minecraft Bingo do Lorgon111, exigem que você copie e cole comandos no bate-papo para inserir um número.)

Obrigado abrightmoore pelo filtro MCEdit de etiquetas de bloco .

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

Não concorrente devido a dificuldades na entrada, e não tenho idéia de como contar bytes nessa coisa (o sistema blytes é defeituoso para blocos de comando).

Cálculo lambda binário , 4,125 bytes

Entrada e saída como numerais da igreja .

00000000 01011111 01100101 11101101 0

No cálculo lambda , é λ m . λ n . λ f . λ x . m f ( n f x ).

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

O cálculo lambda é uma maneira concisa de descrever um mapeamento (função).

Por exemplo, esta tarefa pode ser escrita como λ x . λ y . x + y

O ponto a ser observado é que isso não é uma lambda (função) que recebe dois argumentos. Este é realmente um lambda aninhado. No entanto, ele se comporta como um lambda, que recebe dois argumentos e pode ser descrito informalmente como tal. Todo lambda formalmente leva apenas um argumento.

Por exemplo, se aplicarmos este lambda a 3 e 4:

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

Portanto, o primeiro lambda realmente retorna outro lambda.

Os numerais da igreja são uma maneira de acabar com os sinais extras, deixando apenas símbolos e variáveis ​​lambda.

Cada número no sistema da Igreja é na verdade um lambda que especifica quantas vezes a função é aplicada a um item.

Deixe a função ser f e o item seja x .

Portanto, o número 1 corresponderia a λ f . λ x . f x , o que significa aplicar f a x exatamente uma vez.

O número 3, por exemplo, seria λ f . λ x . f ( f ( f x )), o que significa aplicar f a x exatamente três vezes.

Portanto, para adicionar dois números da Igreja (digamos, m e n ) juntos, é o mesmo que aplicar f a x , m + n vezes.

Podemos observar que é o mesmo que aplicar primeiro f a x , n vezes e depois aplicar f ao item resultante m vezes.

Por exemplo, 2 significaria f(f(x))e 3 significaria f(f(f(x))), então 2 + 3 seria f(f(f(f(f(x))))).

Para aplicar f a x , n vezes, temos n f x .

Você pode visualizar m e n como funções que recebem dois argumentos, informalmente.

Em seguida, aplicamos f novamente a esse item resultante, m vezes: m f ( n f x ).

Em seguida, adicionamos de volta o padrão para obter λ m . λ n . λ f . λ x . m f ( n f x ).

Agora, temos que convertê-lo para o índice De Bruijn .

Primeiro, contamos a "distância relativa" entre cada variável para a declaração lambda. Por exemplo, o m teria uma distância de 4, porque é declarado 4 lambdas "atrás". Da mesma forma, n teria uma distância de 3, f teria uma distância de 2 e x teria uma distância de 1.

Então, escrevemos como esta forma intermediária: λ m . λ n . λ f . λ x . 4 2 (3 2 1)

Em seguida, removemos as declarações da variável, deixando-nos com: λ λ λ λ 4 2 (3 2 1)

Agora, nós o convertemos em cálculo lambda binário .

As regras são:

• λ se torna 00.
• m n (agrupamento) se torna 01 m n.
• números i se torna 1 i vezes + 0, por exemplo 4 se torna 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 comum, 15 bytes

(+(read)(read))

Stack Cats , 8 + 4 = 12 bytes

]_:]_!<X

Corra com as -mnbandeiras. Experimente online!

Jogar golfe no Stack Cats é altamente contra - intuitivo, portanto, este programa acima foi encontrado com alguns dias de força bruta. Para comparação, uma solução mais intuitiva, escrita por humanos, usando o *(...)>modelo, tem dois bytes a mais

*(>-_:[:)>

com as -lnbandeiras (consulte a parte inferior desta postagem para obter uma explicação).

Explicação

Aqui está uma cartilha sobre Stack Cats:

• Stack Cats é uma linguagem esotérica reversível em que o espelho de um trecho desfaz o efeito do trecho original. Os programas também devem ser imagens espelhadas de si mesmos - necessariamente, isso significa que os programas pares são no-ops ou loops infinitos, e todos os programas finais não triviais são de tamanho ímpar (e são essencialmente uma conjugação do operador central).
• Como metade do programa está sempre implícita, metade pode ser deixada de fora com o sinalizador -mou -l. Aqui o -msinalizador é usado, então o meio programa acima se expande para ]_:]_!<X>!_[:_[.
• Como o próprio nome sugere, o Stack Cats é baseado em pilha, com as pilhas sem fundo com zeros (ou seja, operações em uma pilha vazia retornam 0). Na verdade, o Stack Cats usa uma fita de pilhas, por exemplo, <e >move uma pilha para a esquerda e uma pilha para a direita, respectivamente.
• Os zeros no fundo da pilha são engolidos / removidos.
• Toda a entrada é enviada para uma pilha de entradas inicial, com a primeira entrada na parte superior e um -1 extra abaixo da última entrada. A saída é feita no final, usando o conteúdo da pilha atual (com um -1 opcional na parte inferior sendo ignorado). -nindica E / S numérica.

E aqui está um rastro do 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+bé então emitido, com a base -1 ignorada. Observe que a parte mais complicada dessa solução é que a pilha de saída deve ter um -1na parte inferior; caso contrário, uma pilha de saída apenas [-1]ignoraria a base -1 e uma pilha de saída [0]faria com que o zero base fosse engolido (mas uma saída pilha de [2], por exemplo, seria 2muito bem).

Apenas por diversão, aqui está a lista completa de soluções relacionadas do mesmo tamanho encontrado (a lista pode não estar completa):

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

A *(>-_:[:)>solução é mais longa, mas é mais intuitiva de escrever, pois usa o *(...)>modelo. Este modelo se expande para <(...)*(...)>quando usado com o -lsinalizador, o 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, o *(...)>modelo significa que o primeiro loop é pulado, mas o segundo é executado. Isso permite que uma programação mais direta ocorra, pois não precisamos nos preocupar com os efeitos do loop na outra metade do programa.

Nesse caso, o interior do 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

A final >do modelo nos leva de volta à pilha de entrada, onde a+bé gerada.

Flacidez cerebral , 6 bytes

({}{})

Experimente online!

Brain-flak é uma linguagem muito interessante, com duas grandes restrições.

1. Os únicos caracteres válidos são colchetes, ou seja, qualquer um desses caracteres:

   (){}[]<>
   

2. Cada conjunto de colchetes deve ser totalmente correspondido, caso contrário, o programa é inválido.

Um conjunto de colchetes sem nada entre eles é chamado de "nilad". Um nilad cria um certo valor numérico e todos esses nilads próximos um do outro são somados. Um conjunto de colchetes com algo entre eles é chamado de "mônada". Uma mônada é uma função que recebe um argumento numérico. Portanto, os colchetes dentro de uma mônada são avaliados, e esse é o argumento para a mônada. Aqui está um exemplo mais concreto.

O () nilad é igual a 1. Portanto, o seguinte código de falha cerebral:

()()()

É avaliado como 3. A () mônada coloca o valor dentro dela na pilha global. Então o seguinte

(()()())

empurra um 3. O {}nilad exibe o valor no topo da pilha. Como nilads consecutivas são sempre adicionadas, uma sequência de {}somas de todos os principais elementos da pilha. Então, meu código é essencialmente:

push(pop() + pop())

Minecraft 1.10.x, 924 512 bytes

Agradecemos ao @ quat por reduzir o blytecount em 48 pontos e o bytecount em 412.

Tudo bem, então, peguei algumas das idéias dessa resposta e criei uma versão própria, exceto que essa é capaz de aceitar informações não negativas. Uma versão pode ser encontrada aqui no formato de bloco de estrutura.

(nova versão parece meio chata tbh)

Comandos semelhantes à outra resposta:

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 inserir números, desovar em várias vacas e porcos. As vacas representam o valor "n" e os porcos representam o valor "m". O sistema de bloco de comando mata progressivamente as vacas e porcos e atribui valores conforme necessário.

Esta resposta assume que você está em um mundo sem vacas ou porcos que ocorrem naturalmente e que os valores armazenados em "n" e "m" são limpos a cada corrida.

Retina , 42 bytes

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

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

Experimente online!

Explicação

Adicionar números em unário é a coisa mais fácil do mundo, mas depois de introduzir números negativos, as coisas ficam complicadas ...

\d+
$*

Começamos convertendo os números para unários. Isso é feito combinando cada número com \d+e substituindo-o por $*. Esse é um recurso de substituição específico da retina. A sintaxe completa é count$*charactere insere countcópias de character. Ambos podem ser omitidos onde o countpadrão $&é (ou seja, a correspondência em si) e o characterpadrão é 1. Portanto, para cada entrada n, obtemos noutras e ainda temos sinais de menos potenciais, além do separador de espaço. Por exemplo, a entrada 8 -5fornece:

11111111 -11111

Agora, para lidar com números negativos, é mais fácil usar um -1dígito separado . Usaremos -para esse fim.

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

Esta etapa faz duas coisas. Livra-se do espaço, os principais sinais de menos e transforma os 1s após um sinal de menos em -si mesmos. Isso é feito combinando |-1+(ou seja, um espaço ou um número negativo) e executando uma transliteração nele. A transliteração vai de 1ppara -_, mas aqui, se pexpande para todos os caracteres ASCII imprimíveis e _significa excluir. Então, 1s nessas partidas são transformados em -sees e menos e espaços são removidos. Nosso exemplo agora se parece com isso:

11111111-----

+`.\b.

Esse estágio lida com o caso em que há um número positivo e um número negativo na entrada. Nesse caso, haverá 1s e -s na string e queremos que eles sejam cancelados. Isso é feito combinando dois caracteres com um limite de palavras entre eles (já que 1s é considerado um caractere de palavra e -não é) e substituindo a correspondência por nada. Ele +instrui Retina a fazer isso repetidamente até que a corda pare de mudar.

Agora ficamos com apenas 1 s ou apenas - s.

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

Para converter isso de volta em decimal, combinamos toda a entrada, mas, se possível, capturamos um -em grupo 1. Escrevemos o grupo de volta 1(para acrescentar um -a números negativos) e depois escrevemos de volta a duração da partida com $.&(também um recurso de substituição específico da Retina).

Dominó , 38.000 bytes ou 37 blocos

Isso é criado no Simulador de mesa . Aqui está um vídeo e aqui está o arquivo . É um semi-somador padrão, composto por um andportão para o 2^1valor do local e um xorportão para o 2^0valor do local.

Detalhes

• I / O
  • Iniciar - Isso está incluído para maior clareza (não contado no total) e é o que 'chama' ou 'executa' a função. Deve ser 'pressionado' após a entrada ser dada [Amarelo] .
  • Entrada A - É incluída para maior clareza (não contada no total) e é 'pressionada' para indicar a 1e não pressionada para 0 [Verde] .
  • Entrada B - É incluída para maior clareza (não contada no total) e é 'pressionada' para indicar a 1e não pressionada para 0 [Azul] .
  • Saída - é contada no total. Esses dominós declaram a soma. A esquerda é 2^1e a direita é 2^0 [Preto] .
• Pressionando
  • Para dar entrada ou iniciar a cadeia, crie o mármore de metal
  • Defina a força de elevação para 100%
  • Levante o mármore acima do dominó desejado
  • Largue o mármore

Haskell, 3 bytes

(+)

Os parênteses estão aqui porque precisa ser uma função de prefixo. É o mesmo que fazer uma seção da função +, mas nenhum argumento é aplicado. Também funciona em uma ampla variedade de tipos, como vetores, matemáticas, números complexos, flutuantes, duplos, racionais e, obviamente, números inteiros implementados adequadamente.

Como esse é o Haskell, veja como fazê-lo no nível de tipo. Isso será feito no tempo de compilação, em vez do tempo de execução:

-- 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 da Haskell Wiki

Mathematica, 4 2 bytes

Tr

_{O riscado 4 ainda é regular 4 ...} Tr aplicado a uma lista unidimensional leva a soma dos elementos da lista.

dc, 2 bytes

+f

Adiciona os dois principais itens da pilha (retirados anteriormente stdin) e depois despeja o conteúdo da pilha em stdout.

EDIT: Após uma análise mais aprofundada, parece que há várias maneiras de implementar isso, dependendo do comportamento de E / S desejado.

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

Suponho que a forma mais completa para a soma seria esta:

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

Esperar! Dois números podem ser obtidos na mesma linha, separados por um espaço! Isso nos dá:

?+p

Linguagem de programação de 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]

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]

Estou usando o compilador SPL do drsam94 para compilar isso. Testar:

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

Braquilog , 2 bytes

+.

Espera uma lista com os dois números como entrada

Como alternativa, se você quiser a resposta para STDOUT:

+w

JavaScript (ES6), 9 bytes

a=>b=>a+b

PHP, 20 bytes

Surpreendentemente curto desta vez:

<?=array_sum($argv);

Executa a partir da linha de comando, como:

$ php sum.php 1 2

Queijo Cheddar, 3 bytes

(+)

Este é um recurso interessante do Cheddar chamado "operadores funcionalizados". O crédito para essa ideia vai para @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Aqui estão mais exemplos de operadores funcionalizados:

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

Python, 11 3 bytes

sum

int.__add__

Um operador especial simples.

Traço da geometria - 15 objetos

Finalmente pronto.
15 objetos não são muito, mas ainda era um pesadelo fazer isso (especialmente por causa dos números negativos).

Como eu teria que inserir 15 imagens aqui para saber como reproduzir isso, enviei o nível. O ID do nível é 5216804. A descrição informa como executá-lo e você pode copiá-lo, pois é copiável.

Explicação:

O gatilho superior esquerdo (Contagem instantânea 2) verificou se o primeiro adendo era 0. Se sim, verificou se o segundo adendo era positivo ou negativo. Se positivo, transferiu o valor do segundo adendo para a soma (estilo BF, usando loops) e, se negativo, faria o mesmo.

A razão pela qual precisamos verificar se o segundo adendo é positivo ou negativo é que precisaríamos subtrair um do segundo adendo e adicionar um à soma ou adicionar um ao segundo adendo e subtrair um da soma, respectivamente.

Se o primeiro adendo não for zero, ele testa se é positivo ou negativo usando o processo acima. Após uma iteração no loop while, ele testa para verificar se o primeiro adendo é zero e, se for, executa o processo descrito no início da explicação.

Como o Geometry Dash é notavelmente semelhante ao BF, você pode criar uma solução BF com isso.

MATL, 1 byte

s

Aceita uma matriz de dois números inteiros como entrada e os soma. Enquanto o programa simples de +também funciona, isso já foi mostrado para outros idiomas.

Experimente Online

Perl 5.10, 8 bytes

Os dois números a serem adicionados devem estar em duas linhas separadas para que este funcione:

say<>+<>

Experimente este aqui.

Um com entrada na mesma linha ( 14 + 1 bytes para o sinalizador -a )

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

Experimente aqui!

Um com entrada na mesma linha ( 19 + 1 bytes para o sinalizador -a )

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

Experimente este aqui.

Outro, alterando o separador padrão da matriz ( 19 + 1 bytes também para o sinalizador -a )

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

Experimente este aqui!

Fuzzy Octo Guacamole , 1 byte

a

Uma função que recebe entradas da parte superior da pilha e sai pressionando para a pilha.

Exemplo em execução no REPL:

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

Lote, 25 18 16 bytes

@cmd/cset/a%1+%2

Edit: economizou 7 9 bytes usando o meu truque de Alternating Sign Sequence .

PowerShell v2 +, 17 bytes

$args-join'+'|iex

Recebe a entrada como dois argumentos separados da linha de comando, que são preenchidos previamente na matriz especial $args. Formamos uma string com o -joinoperador, concatenando-as junto com a +no meio, e depois canalizamos essa string para Invoke-Expression(semelhante a eval).

Agradeço ao @DarthTwon por me lembrar que, ao lidar com esses programas mínimos, existem vários métodos de obter informações, tudo na mesma contagem de bytes.

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

O PowerShell não é nada senão flexível.

> <> , 7 6 3 bytes

+n;

Intérprete online

Ou tente no TIO com o sinalizador -v.

Experimente online

C, 35 bytes

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

O que eu fiz aqui é adição definida sem o uso de operadores booleanos ou aritméticos. Isso recursivamente faz x os bits da soma por 'xor' e y os bits de transporte por 'e' até que não haja transporte. Aqui está a versão não destruída:

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 removido graças a @LeakyNun

@sum

Esta é uma função anônima que pega uma matriz e fornece a soma. Exemplo de uso:

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

GoLScript , 1 byte (não competitivo)

K

Adiciona os 2 principais números da pilha. É isso aí.

Agora, como para empurrá-los sobre a pilha, eu não tenho idéia. Eu não acho que é possível .. tosse @ CᴏɴᴏʀO'Bʀɪᴇɴ tosse

Linguagem de programação de Shakespeare (SPL), 137 135 bytes

Programa completo, jogado de golfe:

.
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 uma breve explicação:

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

Não tenho certeza se este é o mais curto possível. Verifique a página oficial para mais informações.

Edit 1: Removido o :depois Act Ie Scene Icomo parece que tudo depois do numeral romano é ignorado, economizando 2 bytes.

código de máquina x86_32, 2 bytes

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

Supondo que os dois valores já estejam nos registros ecx e eax, a execução da instrução add adicionará os valores dos dois registros e armazenará o resultado no registro de destino.

Você pode ver o programa completo escrito em C e montagem em linha aqui . A gravação do wrapper em C facilita o fornecimento de entradas e o teste, mas a função de adição real pode ser reduzida para esses dois bytes.