Ввод: два целых числа. Предпочтительно десятичные целые числа, но могут использоваться другие формы чисел. Они могут быть переданы коду при стандартном вводе в качестве аргументов программы или функции или в виде списка.

Вывод: их сумма. Используйте тот же формат для выходных целых чисел, что и для входных целых. Например, ввод 5 16приведет к выводу 21.

Ограничения: пожалуйста, никаких стандартных лазеек. Это код-гольф , ответ в самом низком количестве выигранных байтов.

Примечания: это должно быть довольно тривиально, однако мне интересно посмотреть, как это можно реализовать. Ответ может быть полной программой или функцией, но, пожалуйста, определите, какая это.

Тестовые случаи:

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

Или как CSV:

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

Leaderboard

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>

Желе , 1 байт

+

Попробуйте онлайн!

Также работает в 05AB1E, на самом деле, APL, Braingolf, ,,, (Commata), Factor, Forth, Implicit, J, Джулия, K, kdb +, Keg, Ly, MATL, Pyke, Deorst и Q.

Minecraft 1.10, 221 персонажа (не конкурирует)

Видите ли, это то, с чем нам приходится иметь дело, когда мы делаем карты Minecraft.

Кроме того: в Minecraft нет способа получить строковый ввод, поэтому я немного изменяю, заставляя вас вводить числа в саму программу. (Это несколько оправданно, потому что довольно много карт, таких как Minecraft Bingo от Lorgon111, требуют, чтобы вы копировали и вставляли команды в чат, чтобы ввести число.)

Спасибо, abrightmoore, за фильтр меток блоков 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"}}

Не конкурирует из-за трудностей ввода, и я понятия не имею, как подсчитать байты в этой вещи (система blytes имеет недостатки для командных блоков).

Двоичное лямбда-исчисление , 4,125 байта

Ввод и вывод в виде церковных цифр .

00000000 01011111 01100101 11101101 0

В лямбда-исчислении это λ m . λ н . λ ф . λ x . m f ( n f x ).

Индекс де Брейна : λ λ λ λ 4 2 (3 2 1)

Лямбда-исчисление - это краткий способ описания отображения (функции).

Например, эта задача может быть записана как λ x . λ y . х + у

Следует отметить, что это не лямбда (функция), которая принимает два аргумента. Это на самом деле вложенная лямбда. Тем не менее, он ведет себя как лямбда, которая принимает два аргумента, поэтому его можно неофициально описать как таковой. Каждая лямбда формально принимает только один аргумент.

Например, если мы применим эту лямбду к 3 и 4:

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

Итак, первая лямбда фактически возвращает другую лямбду.

Церковные цифры - это способ избавиться от лишних знаков, оставляя только лямбда-символы и переменные.

Каждое число в церковной системе на самом деле является лямбда-выражением, которое указывает, сколько раз функция применяется к элементу.

Пусть функция будет f, а элемент x .

Итак, число 1 будет соответствовать λ f . λ x . f x , что означает применение f к x ровно один раз.

Число 3, например, будет λ f . λ x . f ( f ( f x )), что означает применение f к x ровно три раза.

Поэтому, чтобы сложить две церковные цифры (скажем, m и n ) вместе, это то же самое, что применить f к x , m + n раз.

Мы можем заметить, что это то же самое, что сначала применить f к x , n раз, а затем применить f к результирующему элементу m раз.

Например, 2 будет означать f(f(x))и 3 будет означать f(f(f(x))), так что 2 + 3 будет f(f(f(f(f(x))))).

Чтобы применить f к x , n раз, мы имеем n f x .

Вы можете просматривать m и n как функции, принимающие два аргумента, неформально.

Затем мы снова применяем f к этому результирующему элементу, m раз: m f ( n f x ).

Затем мы добавляем обратно шаблон для получения λ m . λ н . λ ф . λ x . m f ( n f x ).

Теперь мы должны преобразовать его в индекс Де Брюина .

Во-первых, мы подсчитываем «относительное расстояние» между каждой переменной до лямбда-объявления. Например, m будет иметь расстояние 4, потому что оно объявлено 4 лямбда "назад". Аналогично, n будет иметь расстояние 3, f будет иметь расстояние 2, а x будет иметь расстояние 1.

Итак, запишем это как промежуточную форму: λ m . λ н . λ ф . λ x . 4 2 (3 2 1)

Затем мы удаляем объявления переменных, оставляя нас с: λ λ λ λ 4 2 (3 2 1)

Теперь мы конвертируем его в двоичное лямбда-исчисление .

Правила таковы:

• λ становится 00.
• m n (группировка) становится 01 m n.
• числа я становится 1 я раз + 0, например 4 становится 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

Common Lisp, 15 байт

(+(read)(read))

Стека кошек , 8 + 4 = 12 байт

]_:]_!<X

Беги с -mnфлагами. Попробуйте онлайн!

Гольф в Stack Cats крайне противоречит интуиции, поэтому эта программа, описанная выше, была найдена за несколько дней грубого форсирования. Для сравнения, более интуитивное, написанное человеком решение с использованием *(...)>шаблона на два байта длиннее

*(>-_:[:)>

с -lnфлагами вместо этого (см. объяснение в нижней части этого поста).

объяснение

Вот учебник по Stack Cats:

• Stack Cats - это обратимый эзотерический язык, в котором зеркало фрагмента снимает эффект оригинального фрагмента. Программы также должны быть зеркальными отображениями самих себя - обязательно, это означает, что программы четной длины являются либо безоперационными, либо бесконечными циклами, а все нетривиальные завершающие программы имеют нечетную длину (и, по сути, являются сопряжением центрального оператора).
• Поскольку половина программы подразумевается всегда, одну половину можно оставить с флагом -mили -l. Здесь используется -mфлаг, поэтому приведенная выше половина программы фактически расширяется до ]_:]_!<X>!_[:_[.
• Как следует из названия, Stack Cats основан на стеке, а стеки бездонные с нулями (т. Е. Операции с пустым стеком возвращают 0). Stack Cats фактически использует ленту стеков, например, <и >перемещает одну стопку влево и одну стопку вправо соответственно.
• Нули в нижней части стека проглатываются / удаляются.
• Все входные данные помещаются в начальный стек ввода, причем первый вход находится сверху, а дополнительный -1 - ниже последнего входа. Вывод выполняется в конце, используя содержимое текущего стека (необязательный -1 внизу игнорируется). -nобозначает числовой ввод / вывод.

А вот и след расширенной полной программы ]_:]_!<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затем выводится, а база -1 игнорируется. Обратите внимание, что самая хитрая часть этого решения заключается в том, что выходной стек должен иметь -1внизу, иначе выходной стек просто [-1]проигнорирует основание -1, а выходной стек [0]вызовет проглатывание базового нуля (но выходной стек [2], например, вывел бы 2просто отлично).

Просто для удовольствия, вот полный список связанных решений той же длины (список может быть не полным):

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

*(>-_:[:)>Решение больше, но более интуитивный писать , так как он использует *(...)>шаблон. Этот шаблон расширяется до <(...)*(...)>использования с -lфлагом, что означает:

<       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

Таким образом, *(...)>шаблон означает, что первый цикл пропущен, а второй выполнен. Это позволяет осуществлять более простое программирование, поскольку нам не нужно беспокоиться о последствиях цикла в другой половине программы.

В этом случае внутренняя часть цикла:

>       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+bвыводится.

Brain-flak , 6 байтов

({}{})

Попробуйте онлайн!

Brain-flak - действительно интересный язык с двумя основными ограничениями.

1. Единственными допустимыми символами являются скобки, то есть любой из этих символов:

   (){}[]<>
   

2. Каждый набор скобок должен быть полностью согласован, в противном случае программа недействительна.

Набор скобок, между которыми ничего нет, называется «ниладой». Нилада создает определенное числовое значение, и все эти нилады рядом друг с другом складываются. Набор скобок с чем-то между ними называется «монадой». Монада - это функция, которая принимает числовой аргумент. Таким образом, скобки внутри монады оцениваются, и это аргумент для монады. Вот более конкретный пример.

() Nilad равен 1. Итак следующий мозга зенитной код:

()()()

Оценивается как 3. () Монада помещает значение внутри него в глобальный стек. Итак, следующее

(()()())

нажимает 3. {}nilad выскакивает значение на вершине стека. Так как последовательные nilads всегда добавляются, строка {}сумм всех верхних элементов в стеке. Так что мой код по сути:

push(pop() + pop())

Minecraft 1.10.x, 924 512 байт

Спасибо @ quat за сокращение blytecount на 48 пунктов и bytecount на 412.

Итак, я взял некоторые идеи из этого ответа и сделал свою собственную версию, за исключением того, что эта способна принять неотрицательный вклад. Версия может быть найдена здесь в формате структурного блока.

(новая версия выглядит скучно)

Подобные команды как другой ответ:

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

Для ввода чисел, порождайте количество коров и свиней. Коровы будут представлять значение «n», а свиньи будут представлять значение «m». Система командных блоков будет постепенно убивать коров и свиней и назначать значения по мере необходимости.

Этот ответ предполагает, что вы находитесь в мире без естественных коров или свиней и что значения, сохраненные в «n» и «m», очищаются при каждом запуске.

Сетчатка , 42 байта

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

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

Попробуйте онлайн!

объяснение

Добавление чисел в унарное - это самая простая вещь в мире, но как только вы вводите отрицательные числа, все становится сложнее ...

\d+
$*

Начнем с преобразования чисел в одинарные. Это делается путем сопоставления каждого числа с \d+и замены его на $*. Это специфичная для Retina функция замещения. Полный синтаксис есть count$*characterи вставляет countкопии character. Оба из них могут быть опущены там, где по countумолчанию $&(т.е. само совпадение) и по characterумолчанию 1. Таким образом, для каждого ввода nмы получаем nединицы, и у нас все еще есть потенциальные минус, а также пробел. Например, вход 8 -5дает:

11111111 -11111

Теперь для работы с отрицательными числами проще всего использовать отдельную -1цифру. Мы будем использовать -для этой цели.

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

Этот этап делает две вещи. Он избавляется от пробела, ведущих минус, и превращает буквы 1s после минуса в -себя. Это делается путем сопоставления |-1+(т. Е. Либо пробела, либо отрицательного числа) и выполнения над ним транслитерации. Транслитерация идет от 1pдо -_, но здесь pраспространяется на все печатные символы ASCII и _означает удаление. Поэтому 1s в этих матчах превращаются в -s, а минусы и пробелы удаляются. Наш пример теперь выглядит так:

11111111-----

+`.\b.

Этот этап обрабатывает случай, когда на входе есть одно положительное и одно отрицательное число. Если это так, в строке будут 1s и -s, и мы хотим, чтобы они отменились. Это делается путем сопоставления двух символов с границей слова между ними (поскольку 1s считается символом слова, а -не символом ) и заменой соответствия ничем. В +инструктирует Retina сделать это несколько раз , пока строка не перестанет изменяться.

Теперь мы остались только 1 с или только - с.

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

Чтобы преобразовать это обратно в десятичное, мы сопоставляем весь ввод, но если возможно, мы записываем -в группу 1. Мы записываем группу обратно 1(чтобы добавить a -к отрицательным числам), а затем записываем длину совпадения с помощью $.&(также специфичной для Retina функции подстановки).

Домино , 38 000 байт или 37 тайлов

Это создано в Tabletop Simulator . Вот видео и вот файл . Это стандартная половина сумматора, состоящая из andшлюза для 2^1значения места и xorшлюза для 2^0значения места.

Детали

• I / O
  • Начало - это включено для ясности (не учитывается в общем) и является тем, что «вызывает» или «выполняет» функцию. Должен быть «нажат» после ввода [Желтого] .
  • Вход A - Это включено для ясности (не в счет к общему количеству) и «нажато» для обозначения a 1и не нажато для 0 [Green] .
  • Вход B - Это включено для ясности (не в счет к общему количеству) и «нажато» для обозначения a 1и не нажато для 0 [Синего] .
  • Вывод - это считается к общему количеству. Эти домино объявляют сумму. Слева есть, 2^1а справа - 2^0 [Черный] .
• прессование
  • Чтобы ввести или запустить цепочку, возродить металлический мрамор
  • Установите силу подъема на 100%
  • Поднимите мрамор над нужным домино
  • Брось мрамор

Haskell, 3 байта

(+)

Скобки здесь, потому что это должна быть префиксная функция. Это то же самое, что взять часть функции +, но аргументы не применяются. Он также работает с широким диапазоном типов, таких как правильно реализованные векторы, матрицы, комплексные числа, числа с плавающей запятой, двойные числа, рациональные числа и, конечно, целые числа.

Поскольку это Haskell, вот как это сделать на уровне типов. Это будет сделано во время компиляции, а не во время выполнения:

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

Код адаптирован из Haskell Wiki

Mathematica, 4 2 байта

Tr

_{Вычеркнуто 4 все еще регулярно 4 ...} Tr применяется к одномерному списку берет сумму элементов указанного списка.

Язык программирования Шекспира , 155 152 байта

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

Я использую компилятор SPL drsam94 для компиляции этого. Тестировать:

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

Брахилог , 2 байта

+.

Ожидается список с двумя числами в качестве ввода

В качестве альтернативы, если вы хотите получить ответ STDOUT:

+w

постоянный ток, 2 байта

+f

Добавляет два верхних элемента в стек (ранее взятые из stdin), а затем выгружает содержимое стека в stdout.

РЕДАКТИРОВАТЬ: После дальнейшего рассмотрения, кажется, есть несколько способов, которыми это может быть реализовано, в зависимости от желаемого поведения ввода / вывода.

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

Я полагаю, что наиболее полная форма суммы будет такой:

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

Подождите! Два числа могут быть взяты на одной строке, разделенные пробелом! Это дает нам:

?+p

JavaScript (ES6), 9 байт

a=>b=>a+b

PHP, 20 байт

Удивительно короткое время:

<?=array_sum($argv);

Запускается из командной строки, например:

$ php sum.php 1 2

Чеддер, 3 байта

(+)

Это отличная особенность чеддера, называемая «функционализированные операторы». Кредит на эту идею идет к @ CᴏɴᴏʀO'Bʀɪᴇɴ.

Вот еще примеры функционализированных операторов:

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

Python, 11 3 байта

sum

int.__add__

Простой специальный оператор.

Геометрия тире - 15 объектов

Наконец, сделали.
15 объектов не так много, но это все еще было кошмаром (особенно из-за отрицательных чисел).

Поскольку мне нужно вставить 15 изображений, чтобы воспроизвести это, я только что загрузил уровень. Идентификатор уровня: 5216804. В описании рассказывается, как его запустить, и вы можете скопировать его, так как он является копируемым.

Объяснение:

Верхний левый триггер (Instant Count 2) проверил, было ли первое добавление 0. Если это было так, то он проверил, было ли второе добавление положительным или отрицательным. Если оно было положительным, оно переводило значение из второго сложения в сумму (в стиле BF, используя циклы) и, если оно было отрицательным, оно делало бы то же самое.

Причина, по которой нам нужно проверить, является ли второе добавление положительным или отрицательным, состоит в том, что нам нужно вычесть одно из второго сложения и добавить одно к сумме или добавить одно во второе добавление и вычесть одно из суммы соответственно.

Если первое добавление не равно нулю, оно проверяет, является ли оно положительным или отрицательным, используя вышеописанный процесс. После одной итерации в цикле while он проверяет, является ли первое добавление нулевым, и если да, то выполняет процесс, описанный в начале объяснения.

Поскольку Geometry Dash очень похож на BF, вы можете сделать из этого решение BF.

MATL, 1 байт

s

Принимает массив из двух целых чисел в качестве входных данных и суммирует их. Хотя простая программа +также работает, это уже было показано для других языков.

Попробуйте онлайн

Perl 5,10, 8 байт

Два числа, которые нужно добавить, должны быть на двух отдельных строках, чтобы этот работал:

say<>+<>

Попробуйте это здесь.

Один с вводом в той же строке ( 14 + 1 байт для флага -a )

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

Попробуй это здесь!

Один с вводом в той же строке ( 19 + 1 байт для флага -a )

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

Попробуйте это здесь.

Еще один, изменяя разделитель по умолчанию для массива ( 19 + 1 байт для флага -a )

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

Попробуйте это здесь!

Нечеткое окто гуакамоле , 1 байт

a

Функция, которая принимает входные данные с вершины стека и выводит их, передавая их в стек.

Пример работы в REPL:

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

Пакет, 25 18 16 байтов

@cmd/cset/a%1+%2

Редактировать: сохранено 7 9 байт, используя мой трюк из Alternating Sign Sequence .

PowerShell v2 +, 17 байт

$args-join'+'|iex

Принимает ввод как два отдельных аргумента командной строки, которые предварительно заполняются в специальный массив $args. Мы формируем строку с -joinоператором, объединяя их вместе с a +посередине, а затем направляем эту строку Invoke-Expression(аналогично eval).

Спасибо @DarthTwon за напоминание о том, что при работе с такими минимальными программами существует несколько способов получения входных данных с одинаковым количеством байтов.

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

PowerShell - ничто, если не гибкий.

> <> , 7 6 3 байта

+n;

Онлайн переводчик

Или попробуйте на TIO с флагом -v.

Попробуйте онлайн

C 35 байт

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

То, что я сделал здесь, это определенное сложение без использования логических или арифметических операторов. Это рекурсивно делает x суммой битов на «xor», а y - битами переноса на «и», пока не будет переноса. Вот негольфированная версия:

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 байта

1 байт удален благодаря @LeakyNun

@sum

Это анонимная функция, которая принимает массив и выдает сумму. Пример использования:

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

GoLScript , 1 байт (неконкурентный)

K

Добавляет 2 верхних числа в стек. Вот и все.

Теперь , как толкать их на стеку, я не имею ни малейшего понятия. Я не думаю, что это возможно .. кашель @ CᴏɴᴏʀO'Bʀɪᴇɴ кашель

Язык программирования Шекспира (SPL), 137 135 байтов

Полная программа, игра в гольф:

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

И краткое объяснение:

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

Я не уверен, что это самый короткий путь. Проверьте официальную страницу для получения дополнительной информации.

Редактировать 1: Убрал :после Act Iи, Scene Iкак кажется, все, что после римской цифры, игнорируется, сохраняя 2 байта.

машинный код x86_32, 2 байта

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

Предполагая, что эти два значения уже находятся в регистрах ecx и eax, выполнение инструкции add добавит значения двух регистров и сохранит результат в регистре назначения.

Вы можете увидеть полную программу, написанную на C, и встроенную сборку здесь . Написание оболочки на C облегчает предоставление входных данных и выполнение тестирования, но фактическая функция add может быть уменьшена до этих двух байтов.