Добавьте два числа

44

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

Вывод: их сумма. Используйте тот же формат для выходных целых чисел, что и для входных целых. Например, ввод 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

dkudriavtsev
источник
26
Это довольно тривиально, но не намного проще, чем, например, каталог Hello World. Учитывая, что возможность добавления целых чисел является одним из двух наших требований к языкам программирования, я бы сказал, что стоит его правильно указать.
Деннис
1
Может ли ответ принять ввод с предыдущими нулями по умолчанию? например 5 16, вводится как005 016
FinW
@FinW Конечно. Пока они не интерпретируются как восьмеричные.
дкудрявцев

Ответы:

38

Желе , 1 байт

+

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

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

Деннис
источник
3
Также работает в Swift.
Захари
3
Pyth также @ Zacharý
Stan
66

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

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

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

Спасибо, abrightmoore, за фильтр меток блоков MCEdit.

a

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
Это, безусловно, лучший. Удивительно.
дкудрявцев
Я не думаю, что жесткое кодирование входных данных является допустимым, но я не знаю достаточно о командных блоках в Minecraft, чтобы иметь возможность судить, есть ли способ получить ввод, отличный от жесткого кодирования. Возможно, один из наших постоянных экспертов Minecraft мог бы взвесить.
Mego
3
Да, в MC нет ввода текста, кроме «пожалуйста, скопируйте и вставьте эту команду». Цифровая клавиатура возможна с / tellraw, но ее практически невозможно будет использовать во всех играх, не говоря уже о 500 КБ, благодаря неприлично строгому синтаксису / Tellraw. Я полагаю, что альтернативой было бы подсчитать что-то в мире, например, свиней + коров или красную шерсть + голубую шерсть.
четверг
1
@quat Поскольку мы обычно используем хоппер для подсчета вещей в майнкрафте, я думаю, что это будет путь. Другой способ справиться с этим можно было бы сделать и в чистом редстоуне, используя рычаги. Поскольку у нас нет никаких ограничений, и бит является самой большой естественной величиной, достижимой в minecraft, это привело бы к простому добавлению двух битов с выводом двух битов (возможно:. 0,1,2Другое решение состояло бы в том, чтобы взять 2 байта и выходной на 9 провода, но будет намного меньше в гольфе.
Katenkyo
39

Двоичное лямбда-исчисление , 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

Дрянная Монахиня
источник
18
Я хотел бы видеть исходный файл размером 4,125 байта, который вы передаете интерпретатору / компилятору.
Мартин Эндер
8
@MartinEnder Скажи это каждому ответу здесь .
Дрянная Монахиня
5
Я хотел бы увидеть решение 0,875 байт, пожалуйста.
Мистер Листер
3
По мета-консенсусу , если вы не можете сохранить программу в виде файла с небольшим количеством байтов, вы должны округлить.
Павел
24

Common Lisp, 15 байт

(+(read)(read))
Беонггон Ли
источник
2
Добро пожаловать в Программирование Пазлов и Code Golf!
Деннис
Я относительно незнаком с CLisp, но можно ли убрать пробелы? (+(read)(read))
Мего
@ Мего Ты прав, это возможно. Я не знал этого, потому что я также новичок в Common Lisp, спасибо за информацию! Я отредактировал источник
Byeonggon Lee
3
Я думаю, что мы оба узнали кое-что здесь! Добро пожаловать на борт PPCG!
Mego
21

Стека кошек , 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выводится.

Sp3000
источник
19

Brain-flak , 6 байтов

({}{})

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

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

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

    (){}[]<>
    
  2. Каждый набор скобок должен быть полностью согласован, в противном случае программа недействительна.

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

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

()()()

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

(()()())

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

push(pop() + pop())
DJMcMayhem
источник
15

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», очищаются при каждом запуске.

Аддисон Крамп
источник
Для отрицательных целых чисел вы могли бы использовать 2 других вида животных в качестве "неганималов" - например, 5 лошадей могут представлять -5.
Mego
@Mego Тогда было бы четыре входа, а не 2.
Аддисон Крамп
Это все равно будет два ввода - это эквивалент использования дополнения до двух для отрицательных чисел. Немного другой формат, но все же один вход. По крайней мере, это мои два цента.
Mego
Может быть в состоянии сэкономить на блоках с помощью execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1, так что вам не нужны никакие формы часов.
четверг
@ quat Ооо. Ницца.
Эддисон Крамп
14

Сетчатка , 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 функции подстановки).

Мартин Эндер
источник
2
Это очень умно.
Mego
Теперь если бы был простой способ реализовать rangeв Retina. Я пробовал несколько раз, но негативы - это боль.
mbomb007
Для добавления двух чисел на этом языке требуется более 40 байтов.
Дкудрявцев
2
@DmitryKudriavtsev хорошо, Retina не имеет понятия о числах ...
Мартин Эндер
@DmitryKudriavtsev, и это только целые числа ....
msh210
14

Домино , 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%
    • Поднимите мрамор над нужным домино
    • Брось мрамор
NonlinearFruit
источник
1
... как?
dkudriavtsev
4
@Mendeleev Как только у вас есть все бинарные логические элементы , все остальное становится на свои места xD.
Нелинейный
10

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

Lazersmoke
источник
3
Забавный факт: это полиглот с
Чеддером
10

Mathematica, 4 2 байта

Tr

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

LegionMammal978
источник
9

Язык программирования Шекспира , 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
медь
источник
8

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

+.

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

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

+w
Fatalize
источник
8

постоянный ток, 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
Джо
источник
Я не вижу, как использовать первый пример +f, dc -e "?+p"здесь все в порядке.
Ясен
1
@Jasen +fВерсия работает, если вы уже положили (ровно два) числа в стек. Я действительно не знал, должен ли dcI / O быть std(in|out)или стек. Оглядываясь назад, это был наименее разумный вариант, чтобы поставить его наверх. : /
Джо
правила говорят, что стек в порядке, насколько я могу судить,
Jasen
7

JavaScript (ES6), 9 байт

a=>b=>a+b
Патрик Робертс
источник
Я не думаю, что вложенная функция считается функцией с двумя входами в javascript
гордый haskeller
4
@proudhaskeller да, это так
Патрик Робертс
1
Этот работает и в C #.
Grax32
7

PHP, 20 байт

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

<?=array_sum($argv);

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

$ php sum.php 1 2
insertusernamehere
источник
Ваш сценарий также принимает, php sum.php 1 2 3 4 5 6поэтому я не уверен на 100%, все ли в порядке.
timmyRS
@timmyRS Представление должно работать для определенного формата ввода - два целых числа. Я не думаю, что это должно обрабатывать и другие входные данные.
insertusername здесь
Что если имя исходного файла начинается с цифры? :)
Алекс Ховански
@AlexHowansky Psssssssst - не говори никому. ;) Это странность при запуске из файла. Вы все еще можете выполнить его, используя -rфлаг - тогда это больше не проблема.
insertusername здесь
7

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

(+)

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

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

(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5
Downgoat
источник
6

Python, 11 3 байта

sum

int.__add__

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

Дрянная Монахиня
источник
6

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

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

введите описание изображения здесь

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

Объяснение:

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

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

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

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

MilkyWay90
источник
5

MATL, 1 байт

s

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

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

Suever
источник
5

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"

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

Пол Пикард
источник
2
Эй, еще один хороший пример (если это в конечном итоге будет проблемой каталога) - это метод, описанный Деннисом в этом посте: codegolf.stackexchange.com/q/32884 (ab) с использованием -pфлага.
Дом Гастингс
Вместо того say$F[0]+$F[1], say pop()+popработает (проверено в Strawberry 5.20.2 с -E) и экономит байт.
msh210
5

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

a

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

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

>>> 8 9 :
[8,9]
>>> a :
17
Rɪᴋᴇʀ
источник
5

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

@cmd/cset/a%1+%2

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

Нил
источник
5

PowerShell v2 +, 17 байт

$args-join'+'|iex

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


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

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

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

AdmBorkBork
источник
1
Да, я просто преследую тебя здесь: P Альтернативные ответы: $args[0]+$args[1]иparam($a,$b)$a+$b
ThePoShWolf
5

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

+n;

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

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

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

Emigna
источник
Поскольку вопрос позволяет определить функцию, я полагаю, что простого +было бы достаточно: оно извлекало бы два числа из стека и помещало результат их сложения обратно в стек. Также -vможно было бы избежать затрат , так как считывание чисел могло быть сделано заранее до вызова функции.
Аарон
1
@ Аарон: Правда. Но так как это решение уже опубликовано для нескольких других языков, я оставлю это как полную программу.
Эминья
1
Я думал, что флаг v будет максимум +1 байт, но в любом случае вы можете использовать интерпретатор fishlanguage.com, и ваш общий объем составит 3 байта (ему не нужен -v).
redstarcoder
@redstarcoder: каждый всегда указывает флаг как 3 байта для рыбы (и 1 байт для всех остальных языков, кажется). Не уверен, почему это отличается, но я предполагаю, что это по уважительной причине.
Emigna
В любом случае, вам не нужен флаг, если вы просто используете интерпретатор fishlanguage.com. У вас есть ссылка на мета? Я не видел ни одной>> программы, получающей дополнительные байты для использования целых чисел в начальном стеке (я тоже это сделал).
redstarcoder
5

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);
}
Bijan
источник
Почему бы вам просто не добавить напрямую?
Esolanging Fruit
Мне показалось, что скучно, полностью играющая в гольф версия тривиальна.
Bijan
«Все ответы должны показывать некоторые усилия для достижения лучшего результата. Например, ответы на вопросы по коду для гольфа должны быть максимально короткими (в пределах ограничений выбранного языка)». (из codegolf.meta.stackexchange.com/a/7073/61384 )
Esolanging Fruit,
2
Очевидно, я думал просто о добавлении чисел и приложил усилия, чтобы сделать его короче, только под альтернативными ограничениями. Я думаю, так как это нестандартный вопрос, он заслуживает нетрадиционного ответа. Следуя этому правилу слово в слово, не было бы никакой причины когда-либо выдвигать ответ, если кто-то уже выдвинул более короткий ответ. Если вы установили свое 20-байтовое решение Python, а у кого-то уже есть 4-байтовая версия, то вы доказываете, что не знаете, как копировать и вставлять. Люди предлагают 20-байтовые решения, потому что мы ценим оригинальность.
Биджан,
1
Подразумевается, что он конкурентоспособен на выбранном вами языке. Однако, прочитав мета, кажется, что я не могу утверждать, что ваш ответ недействителен («Ответ может реализовывать любой алгоритм, даже если существуют более подходящие для игры в гольф»), поэтому, я думаю, я его отброшу.
Esolanging Fruit
4

MATLAB, 4 байта

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

@sum

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

>> f = @sum
f = 
    @sum
>> f([3 4])
ans =
     7
Луис Мендо
источник
Как насчет sum?
Утренняя монахиня
@LeakyNun Спасибо, хорошая идея!
Луис Мендо
43 байта? xD Кстати: я думал, что у нас должна быть полная программа или функция , поэтому я бы сказал, что только @sumправильный ответ. Или есть другой мета-консенсус?
flawr
@ Flawr Я думаю, что да, да. Но я не смог его найти
Луис Мендо
4
Wooah, я помог вам уменьшить с 43 до 4 байтов XD
flawr
4

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

K

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

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

Rɪᴋᴇʀ
источник
Explanation soon to be coming.- Райкер 3 июля 16 года
MD XF
+1 за язык игры жизни.
Сильно радиоактивный
4

Язык программирования Шекспира (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 байта.

Ioannes
источник
5
Это недействительно Персонажи должны быть из пьес Шекспира, и они должны быть там. Кроме того, вам нужно запятую после имени каждого персонажа для описания.
Оливер Ни
4

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

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

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

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

Davey
источник
3
Это не функция, просто фрагмент. Вам также нужна retинструкция (один байт). И это при условии, что пользовательское соглашение о вызовах eaxиспользуется как регистр передачи аргументов. (Учебная библиотека asv Irvine32 делает это, но никакие стандартные соглашения о вызовах для x86-32 или x86-64 не делают этого, в отличие от ARM, где регистр возвращаемого значения r0также является первым регистром передачи аргументов.) Пользовательские соглашения о вызовах хороши в Хотя asm работает, вам не нужно менять его на 3 байта lea (%ecx, %edx), %eax+ 1 байт retдля Microsoft __fastcallили gcc -mregparm.
Питер Кордес
1
Тем не менее, это интересная задача для соглашения о вызове стековых аргументов. popтолько 1 байт, но для espрежимов относительной адресации требуется байт SIB. Таким образом, соглашение о вызове вызывающего абонента может pop %ecx(адрес возврата), pop %eax/ pop %edx/ add %edx, %eax(2 байта) / jmp *%ecx(2 байта) = всего 7 байтов. против mov 4(%esp), %eax(4B) / add 8(%esp), %eax(4B) / ret= 9 байт или 11 байт для версии с использованием вызывающего абонента ret imm16, если я сделал это правильно. Это дополнительный 1 байт для SIB с ESP в качестве базы и дополнительный 1 байт для disp8 в каждом insn.
Питер Кордес