加两个数字

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

排行榜

显示代码段

code-golf  arithmetic 
— 德库德里阿夫采夫
source
26
这是相当琐碎的，但并不比例如Hello World目录简单得多。鉴于加整数的能力是我们对编程语言的两个要求之一，我想说如果正确指定它是值得的。
— 丹尼斯，
1
答案是否可以将输入以零开头作为默认值？例如5 16，输入为005 016
— FinW
@FinW当然。只要它们不被解释为八进制。
— dkudriavtsev

Answers:

38

果冻，1字节

+

在线尝试！

也适用于05AB1E，实际上，APL，Braingolf，``，（逗号），Factor，Forth，Implicit，J，Julia，K，kdb +，Keg，Ly，MATL，Pyke，Deorst和Q.

— 丹尼斯
source
3
也可以在Swift中使用。
— 扎卡里
3
Pyth以及@扎卡里
— 斯坦乱弹
66

Minecraft 1.10，221个字符（非竞争）

瞧，这是制作Minecraft地图时必须处理的内容。

另外：在Minecraft中无法进行字符串输入，因此我通过让您将数字输入程序本身来作弊。（这是合理的，因为很多地图，例如Lorgon111的Minecraft Bingo，都要求您将命令复制并粘贴到聊天中才能输入数字。）

感谢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系统存在命令块缺陷）。

— qua
source
4
这是迄今为止最好的。惊人。
— dkudriavtsev '16
我认为对输入进行硬编码不是有效的方法，但是我对Minecraft中的命令块了解不足，无法判断是否有其他方法可以进行硬编码输入。也许我们的居民的Minecraft专家之一，可能会拖累英寸
— 美高
3
是的，除了“请复制并粘贴此命令”外，MC中的文本输入为零。/ tellraw可以使用数字键盘，但是由于/ tellraw严格的语法，因此几乎不能用于所有高尔夫球，更不用说500kb了。我想可以用另一种方式来计算世界上的东西，例如猪+牛，或红色羊毛+蓝色羊毛。
— 2016年
1
@quat由于我们通常使用料斗来计算《我的世界》中的事物，因此我想这是可行的方法。处理这种情况的另一种方法也可以通过使用杠杆在纯红石中实现。由于我们没有任何限制，并且该位是Minecraft中可达到的最大自然值，因此将导致简单地将两个位相加并输出两个位（可能：0,1,2。另一种解决方案是取2个字节，通过9线输出，但不会像高尔夫球一样
— Katenkyo
1
— mbomb007 '16
39

二进制Lambda演算，4.125字节

输入和输出为教堂数字。

00000000 01011111 01100101 11101101 0

在演算，这是λ 米。λ ñ。λ ˚F。λ X。m f（n f x）。

De Bruijn指数：λλλλ4 2（3 2 1）

Lambda演算是描述映射（函数）的简洁方法。

例如，这个任务可以写成λ X。λ ÿ。x + y

需要注意的是，这不是带有两个参数的lambda（函数）。这实际上是一个嵌套的lambda。但是，它的行为就像接受两个参数的lambda一样，因此可以这样非正式地描述。每个lambda都只接受一个参数。

例如，如果我们将此lambda应用于3和4：

（λ X。λ ÿ。X + Ý）3 4≡（λ ÿ 3 + Ý）4≡3 + 4 = 7

因此，第一个lambda实际上返回了另一个lambda。

教堂数字是消除多余符号的一种方法，仅保留lambda符号和变量。

教会系统中的每个数字实际上都是一个lambda，它指定将功能应用于某项的次数。

令函数为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视为带有两个参数的函数。

然后，将m再次应用于此结果项，m次：m f（n f x）。

然后，我们加回样板，以获得λ 米。λ ñ。λ ˚F。λ X。m f（n f x）。

现在，我们必须将其转换为De Bruijn index。

首先，我们计算每个变量与lambda声明之间的“相对距离”。例如，m的距离为4，因为它被声明为4个lambdas“ ago”。同样，n的距离为3，f的距离为2，x的距离为1。

所以，我们把它写，因为这中间形式：λ 米。λ ñ。λ ˚F。λ X。4 2（3 2 1）

然后，我们删除变量声明，只剩下：λλλλ4 2（3 2 1）

现在，我们将其转换为二进制λ演算。

规则是：

  • λ变为00。
  • m n（分组）变为01 m n。
  • 数字i变为1 i乘以+ 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

— 漏尼姑
source
18
我希望看到传递给解释器/编译器的4.125字节源文件。
— Martin Ender
8
@MartinEnder 在这里对每个答案说。
— Leaky Nun
5
我希望看到一个0.875字节的解决方案。
— 李斯特先生，2016年
3
通过元共识，除非您可以将程序存储为字节数很少的文件，否则必须四舍五入。
— Pavel
24

普通Lisp，15个字节

(+(read)(read))
— 李炳根
source
2
欢迎来到编程难题和代码高尔夫球！
— 丹尼斯
我相对不熟悉CLisp，但是是否可以删除空格？(+(read)(read))
— Mego
@Mego你是对的，这是可能的。我不知道，因为我也是Common Lisp的新手，感谢您提供的信息！我编辑了源代码
— Byeonggon Lee 2016年
3
我想我们俩在这里都学到了一些东西！欢迎登上PPCG！
— Mego
21

堆叠猫，8 + 4 = 12字节

]_:]_!<X

用-mn标志运行。在线尝试！

在Stack Cats中打高尔夫球非常违反直觉，因此上述程序在几天内就被蛮力地发现了。为了进行比较，使用*(...)>模板的更直观，人为编写的解决方案要长两个字节

*(>-_:[:)>

-ln而是带有标志（有关说明，请参见本文的底部）。

说明

这是Stack Cats的入门读物：

  • Stack Cats是一种可逆的深奥语言，其中片段的镜像会撤消原始片段的效果。程序还必须是其自身的镜像-必然，这意味着偶数长度的程序要么是无操作的循环，要么是无限循环，并且所有非平凡的终止程序都具有奇长的长度（并且本质上是中央运算符的共轭）。
  • 由于总是隐含程序的一半，因此可以用-m或-l标志忽略一半。这里使用了-m标志，因此上面的一半程序实际上扩展为]_:]_!<X>!_[:_[。
  • 顾名思义，Stack Cats是基于堆栈的，堆栈是无底的，带有零（即，对原本为空的堆栈的操作返回0）。堆叠猫实际上使用一堆堆叠带，例如<，>分别向左移动一个堆叠和向右移动一个堆叠。
  • 堆栈底部的零被吞下/除去。
  • 所有输入都被压入初始输入堆栈，第一个输入在顶部，而最后一个输入在下方增加-1。最后，使用当前堆栈的内容完成输出（底部的可选-1被忽略）。-n表示数字I / O。

这是扩展的完整程序的痕迹]_:]_!<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的底部必须有一个a ，否则，Just的输出堆栈[-1]将忽略以-1为底，而输出的输出堆栈[0]将导致将基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

>然后，模板中的final 将我们移回到输入堆栈，在此a+b输出。

— Sp3000
source
19

脑筋，6个字节

({}{})

在线尝试！

Brain-flak是一种非常有趣的语言，它有两个主要限制。

  1. 唯一有效的字符是方括号，即以下任何字符：

    (){}[]<>
  2. 每组括号必须完全匹配，否则程序无效。

一组没有括号的括号称为“ nilad”。一个nilad会创建一个特定的数值，并将所有这些nilad彼此相邻地相加。一组括号之间的内容称为“单子”。monad是带有数字参数的函数。因此，对monad内部的括号进行了评估，这就是monad的参数。这是一个更具体的例子。

该() nilad等于1所以下面的脑高射炮代码：

()()()

求值为() 3。monad将其内部的值压入全局堆栈。所以以下

(()()())

按{}3。nilad将值弹出堆栈顶部。由于总是添加连续的nilads，因此一串{}求和字符串将堆栈中的所有顶级元素相加。所以我的代码本质上是：

push(pop() + pop())
— DJMcMayhem
source
15

Minecraft 1.10.x，924 512字节

感谢@ quat将blytecount减少了48点，将bytecount减少了412。

好吧，因此，我从这个答案中汲取了一些想法，并做了一个自己的版本，只是这个版本能够接受非负输入。可以在此处找到结构块格式的版本。

group

（新版本看起来有点无聊）

与其他答案类似的命令：

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”中的值。

— 艾迪生·克鲁普（Addison Crump）
source
对于负整数，可以使用2种其他动物作为“负整数”-例如，5匹马可以代表-5。
— Mego
@Mego然后这将是四个输入，而不是2
— 阿狄森Crump的
它仍然是两个输入-相当于对负数使用二进制补码。格式略有不同，但仍然是一种输入。至少那是我的两分钱。
— Mego
可以使用来节省块execute @e[type=Pig] ~ ~ ~ scoreboard players add m a 1，因此您不需要任何形式的时钟。
— 季铵盐
@quat哦。真好
— Addison Crump
14

视网膜，42字节

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

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

在线尝试！

说明

在一元数中加数字是世界上最简单的事情，但是一旦您引入了负数，事情就会变得很奇怪...

\d+
$*

我们首先将数字转换为一元。这是通过将每个数字与匹配\d+并替换为来完成的$*。这是视网膜特定的替换功能。完整语法为，count$*character并插入的count副本character。在count默认为$&（即匹配项本身）和character默认为的情况下，这两个选项都可以省略1。所以对于每个输入n我们都会得到n一个，并且那里仍然有潜在的负号以及空格分隔符。例如，输入8 -5给出：

11111111 -11111

现在，为了处理负数，最简单的方法是使用单独的-1数字。我们将-为此目的使用。

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

这个阶段有两件事。它消除了空格，前导减号，并将1减号后的s变成-自己。这是通过匹配 |-1+（即空格或负数）并对其进行音译来完成的。音译从1p到-_，但在此处p扩展为所有可打印的ASCII字符，_表示删除。因此1，这些匹配中的-s 变为s，负号和空格被删除。现在，我们的示例如下所示：

11111111-----

+`.\b.

此阶段处理输入中有一个正数和一个负数的情况。如果是这样，将会有1和-字符串 s，我们希望它们取消。这是通过匹配两个字符之间具有单词边界的（因为1s被认为是单词字符而-不是单词字符），然后将匹配替换为空而完成的。该+指示视网膜做到这一点，直到弦不再变化。

现在我们只剩下 1 s或仅 -秒。

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

要将其转换回十进制，我们匹配整个输入，但如果可能，我们将a捕获-到group中1。我们写回组1（在a之前加上-负数），然后写回匹配的长度$.&（也是视网膜特定的替换功能）。

— 马丁·恩德
source
2
这是非常聪明的。
— Mego
现在，只要有一种简单的方法即可range在Retina中实施。我已经尝试过几次了，但是负面影响是痛苦的。
— mbomb007'7
用这种语言将两个数字相加需要40多个字节？
— dkudriavtsev
2
@DmitryKudriavtsev好，视网膜没有数字的概念……
— 马丁·恩德
@DmitryKudriavtsev，这只是整数....
— msh210
14

多米诺骨牌，38,000字节或37个图块

这是在Tabletop Simulator中创建的。这是视频，这是文件。它是一个标准的半加法器，由and用于2^1位值的xor门和用于位值的门组成2^0。

enter image description here

细节

  • 输入输出
    • 开始 -包括在内是为了清楚起见（不计入总数），是“调用”或“执行”功能的内容。输入[Yellow]后应“按下” 。
    • 输入A-为清楚起见，将其包括在内（不计入总计），并“按”以指示a，1而未按0 [绿色]。
    • 输入B-为清楚起见，将其包括在内（不计入总计），并“按”以指示a 1，未按0 [蓝色]。
    • 输出 -这计入总计。这些多米诺骨牌声明总和。左边是2^1，右边是2^0 [Black]。
  • 紧迫
    • 要输入或启动链，请生成金属大理石
    • 将举升强度设置为 100%
    • 将大理石抬高到所需的多米诺骨牌上方
    • 放下大理石
— 非线性水果
source
1
...怎么样？
— dkudriavtsev
4
@Mendeleev一旦拥有所有二进制逻辑门，其他所有内容都将置于xD位置。
— NonlinearFruit
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
source
3
有趣的事实：这是切达语的多语种：D
— Downgoat
10

Mathematica，4个 2字节

Tr

划掉的4仍然是常规的4 ... Tr应用于一维列表将采用所述列表元素的总和。

— 军团哺乳动物978
source
9

dc，2个字节

+f

在堆栈中添加前两个项目（以前从中获取stdin），然后将堆栈中的内容转储到stdout。

编辑：经过进一步考虑，似乎有几种方法可以实现，具体取决于所需的I / O行为。

+        # 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
— 乔
source
我看不到如何使用第一个示例+f， dc -e "?+p"在这里工作正常。
— 杰森
1
@Jasen +f如果您已经在堆栈中放入了（恰好两个）数字，则该版本适用。我真的不知道dc应该是I / O std(in|out)还是堆栈。回想起来，这是摆在职位顶端最不明智的选择。：/
— 乔
规则说，据我所知，堆栈是可以的，
— Jasen
9

莎士比亚编程语言，155152字节

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

取消高尔夫：

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]

我正在使用drsam94的SPL编译器对此进行编译。去测试：

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

Brachylog，2个字节

+.

期望有两个数字作为输入的列表

或者，如果您想要答案STDOUT：

+w
— 致命
source
7

PHP，20字节

这次的时间短得令人惊讶：

<?=array_sum($argv);

从命令行运行，例如：

$ php sum.php 1 2
— 在此处插入用户名
source
您的脚本也接受，php sum.php 1 2 3 4 5 6因此我不确定100％是否可以。
— timmyRS
@timmyRS提交应适用于特定的输入格式-两个整数。我认为它也不应处理其他输入。
— 此处插入用户名，2016年
如果源文件名以数字开头怎么办？:)
— Alex Howansky '16
@AlexHowansky Psssssssst –不要告诉任何人。;）这是从文件运行时的怪癖。您仍然可以使用该-r标志执行它-那就不再是问题。
— 此处插入用户名，2016年
7

Cheddar，3个字节

(+)

这是Cheddar的一项很酷的功能，称为“功能化运算符”。这个想法归功于@CᴏɴᴏʀO'Bʀɪᴇɴ。

以下是功能化运算符的更多示例：

(+)(1,2) // 3
(/)(6,2) // 3
(-)(5)   // -5
— 下山羊
source
6

Python，11 3个字节

sum

int.__add__

一个简单的特殊运算符。

— 漏尼姑
source
6

几何破折号-15个对象

终于完成了。
15个对象虽然不多，但是这样做仍然是一场噩梦（尤其是由于存在负数）。

在此处输入图片说明

因为我必须在此处插入15张图像以重现此图像，所以我刚刚上传了关卡。级别ID是5216804。该描述告诉您如何运行它，并且可以复制它，因此可以对其进行复制。

说明：

左上方的触发器（即时计数2）检查第一个加数是否为0。如果是，则检查第二个加数是正还是负。如果为正，则将值从第二个加数转换为总和（BF风格，使用循环），如果为负，则将执行相同的操作。

我们需要检查第二个加数是正数还是负数的原因是，我们需要分别从第二个加数中减去一个，然后将一个加到总和中，或者将一个数加到第二个加数中，然后从和中减去一个。

如果第一个加数不为零，则使用上述过程测试它是正数还是负数。在while循环中进行一次迭代后，它将测试以查看第一个加数是否为零，如果是，则执行说明开头所述的过程。

由于Geometry Dash与BF非常相似，因此您可以使用BF解决方案。

— 银河系90
source
5

MATL，1个字节

s

接受两个整数组成的数组作为输入并求和。虽然简单的程序+也可以使用，但是已经针对其他语言显示了该程序。

在线尝试

— Suever
source
5

Perl 5.10，8个字节

要添加的两个数字必须在2条单独的行上，此数字才能起作用： 

say<>+<>

在这里尝试这个。

一个输入在同一行上（-a标志为14 +1字节）

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

在这里尝试！

一个输入在同一行上（-a标志为19 + 1字节）

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

在这里尝试这个。

另一个，通过更改数组默认分隔符（-a标志也为19 + 1字节）

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

在这里尝试这个！

— 保罗·皮卡德
source
2
嘿，另一个很好的例子（如果这最终将成为目录挑战）是Dennis在本文中概述的方法：codegolf.stackexchange.com/q/32884（ab）使用该-p标志。
— Dom Hastings
代替say$F[0]+$F[1]，say pop()+pop可以工作（在草莓5.20.2中使用进行了测试-E），并为您节省了一个字节。
— msh210
5

模糊章鱼鳄梨，1个字节

a

该函数从堆栈顶部获取输入，并通过压入堆栈来输出。

在REPL中运行的示例：

>>> 8 9 :
[8,9]
>>> a :
17
— Rɪᴋᴇʀ
source
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
source
1
是啊，我只是跟踪你在这里：P备选答案：$args[0]+$args[1]和param($a,$b)$a+$b
— ThePoShWolf
5

> <>，7 6 3个字节

+n;

在线口译

或使用-v标志在TIO上尝试。

在线尝试

— 艾米尼亚
source
由于这个问题可以让您定义一个函数，所以我相信一个简单的方法+就足够了：它将从堆栈中弹出两个数字，并将它们相加的结果放回堆栈中。-v也可以避免这样做的代价，因为读取数字可以事先完成函数调用。
— 亚伦
1
@亚伦：是的。但是由于该解决方案已经发布了其他几种语言，因此我将其作为完整程序保留下来。
— 艾米尼亚
1
我以为v标志最多为+1个字节，但是无论哪种方式，您都可以使用fishlanguage.com解释器，而您的总数将为3个字节（不需要-v）。
— redstarcoder
@redstarcoder：每个人始终将标志指定为fish的3个字节（似乎所有其他语言的1个字节）。不知道为什么会有所不同，但我认为这是有正当理由的。
— Emigna
无论如何，如果只使用fishlanguage.com解释器，则不需要标志。您是否有指向meta的链接？我还没有看到任何> <>程序会在初始堆栈上使用整数来增加字节（我也这样做了）。
— redstarcoder
5

C，35个字节

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

我在这里所做的是定义加法，而不使用布尔或算术运算符。递归地将x的总和与“ xor”相乘，将y的进位与“ and”相乘，直到没有进位。这是非高尔夫版本：

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);
}
— 比扬
source
您为什么不直接添加？
— 硕果累累
我发现无聊的是，完全打高尔夫球的版本是微不足道的。
— Bijan
“所有答案都应显示出为达到更高分数而付出的努力。例如，对高尔夫挑战代码的答案应尽量短（在所选语言的限制范围内）。” （从codegolf.meta.stackexchange.com/a/7073/61384）
— Esolanging水果
2
显然，我只是考虑增加数字，并且确实在不加限制的情况下尽了最大的努力来简化数字。我认为，由于这是一个非常规的问题，因此值得一个非常规的答案。遵循该规则，如果有人已经提出了一个较短的答案，就没有理由提出答案。如果您安装了20字节的python解决方案，并且已经有人安装了4字节的版本，则说明您不知道如何复制和粘贴。人们提出20字节的解决方案，因为我们重视原创性。
— Bijan
1
暗示它在您选择的语言中具有竞争力。但是，在阅读了meta以后，似乎无法断言您的答案无效（“即使有高尔夫球手的答案，答案也可以实现任何算法”），所以我想我将其删除。
— 硕果累累
4

MATLAB，4个字节

由于@LeakyNun，删除了1个字节

@sum

这是一个匿名函数，它接受一个数组并给出总和。使用示例：

>> f = @sum
f = 
    @sum
>> f([3 4])
ans =
     7
— 路易斯·门多
source
那sum呢
— Leaky Nun
@LeakyNun谢谢，好主意！
— Luis Mendo
43个字节？xD BTW：我认为我们必须拥有完整的程序或功能，所以我只能说这@sum是一个有效的答案。还是有另一个元共识？
— 瑕疵的
@flawr我想是的，是的。但是我找不到它
— Luis Mendo
4
哇，我帮助您将XD从43字节减少到4字节
— 更加完善的
4

GoLScript，1个字节（非竞争）

K

将堆栈中的前2个数字相加。而已。

现在，如何把他们的堆栈，我不知道。我认为不可能。. 咳嗽@CᴏɴᴏʀO'Bʀɪᴇɴ咳嗽

— Rɪᴋᴇʀ
source
Explanation soon to be coming.-Riker 16
— MD XF
+1是一种“生活游戏”语言。
— 高度放射性
4

莎士比亚编程语言（SPL），137135字节

高尔夫完整课程：

.
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：删除了:after Act I，Scene I并且似乎忽略了罗马数字之后的所有内容，从而节省了2个字节。

— 约阿尼斯
source
5
这是无效的。角色必须来自莎士比亚的戏剧，并且：s必须存在。另外，每个字符的名称后都需要用逗号作为描述。
— 奥利弗·尼
4

x86_32机器码，2个字节

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

假设两个值已经在ecx和eax寄存器中，执行加法指令将两个寄存器的值相加并将结果存储在目标寄存器中。

您可以在此处看到用C和内联汇编编写的完整程序。用C编写包装器可以更轻松地提供输入和进行测试，但是实际的add函数可以减少到这两个字节。

— 达维
source
3
这不是一个功能，只是一个片段。您还需要一条ret指令（一个字节）。并假设自定义调用约定在其中eax用作arg传递寄存器。（Irvine32 asm教学库可以做到这一点，但是没有x86-32或x86-64的标准调用约定可以做到这一点，而ARM上返回值寄存器r0也是第一个arg传递寄存器。） asm可以正常运行，因此对于Microsoft 或gcc ，您无需将其更改为3字节lea (%ecx, %edx), %eax+ 1字节。ret__fastcall-mregparm
— 彼得·科德斯
1
但是，对于stack-args调用约定，这是一个有趣的挑战。 pop只有1个字节，但esp相对寻址模式需要一个SIB字节。因此，呼叫者砰砰调用约定威力pop %ecx（返回地址），pop %eax/ pop %edx/ add %edx, %eax（2个字节）/ jmp *%ecx（2个字节）= 7个字节总数。vs. mov 4(%esp), %eax（4B）/ add 8(%esp), %eax（4B）/ ret= 9个字节ret imm16，如果使用的话，则为caller-pops版本的11个字节。对于以ESP为基础的SIB，这是一个额外的1字节，对于每个insn中的disp8，这是一个额外的1字节。
— 彼得·科德斯
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.