从1到n的所有整数的和

63

实在令我感到惊讶的是，这还没有完成。如果可以找到现有线程，请务必将其标记为重复或让我知道。

输入项

您的输入采用任何大于或等于1的正整数的形式。

输出量

您必须输出介于1和输入数字之间的所有整数的和。

例

 In: 5
     1+2+3+4+5 = 15
Out: 15

OEIS A000217 —三角数：a（n）=二项式（n + 1,2）= n（n + 1）/ 2 = 0 +1 + 2 + ... + n。

排行榜

运行下面的代码片段以查看此问题答案的页首横幅。（感谢programmer5000和steenbergh提出的建议，以及Martin Ender提出的建议。）

显示代码段

code-golf  math  number 
— GarethPW
source
5
— FryAmTheEggman
@FryAmTheEggman对不起-那里有点放屁。我明白你的意思了。
— GarethPW
2
@Aaron，您收到了Husk的忍者，这是一个1字节的解决方案
— Skidsdev
7
我建议一个堆栈片段。
— 程序员
1
— 杰里耶

Answers:

32

外壳 1字节

Σ

在线尝试！

内置！ΣHusk中的in通常用于获取列表中所有元素的总和，但是当应用于数字时，它会精确返回n*(n+1)/2。

— 狮子座
source
1
出于好奇，是否由于将数字转换为一定范围然后求和而发生，或者这实际上是硬编码的？
— FryAmTheEggman
4
@FryAmTheEggman这实际上是硬编码的，类似于另一个内置函数Π的行为，它可以计算列表的所有元素或单个数字的阶乘的乘积
— Leo
4
Σ是我机器上的两个字节的unicode字符。我猜您使用代码页1253？msdn.microsoft.com/en-us/library/cc195055.aspx
— gmatht
5
@gmatht Husk的代码页
— Jonathan Allan
21

Piet，161字节/ 16个编码

你可以把它解释这皮特解释或上传的图片上这个网站，并运行它。如果我可以不同地编码以减小大小，则不确定字节数。

源图像的放大版本：

强奸形象

说明

的highlighted文本显示当前堆栈（左生长到右），假设用户输入是5：

第一次过渡 输入一个数字并将其压入堆栈

5

第二次过渡 在堆栈上复制此数字

5 5

第三过渡 将1（深红色区域的大小）压入堆栈

5 5 1

第四过渡 将前两个数字相加

5 6

第五过渡 将前两个数字相乘

30

第六过渡 黑色区域确保光标向下移动至浅绿色编码。该过渡将2（深绿色的大小）压入堆栈

30 2

第七过渡 将堆栈上的第二个数字除以第一个数字

15

第八过渡 弹出并输出头号（解释为数字）

[empty]

最终陷阱 通过插入白色区域，过渡为a nop，黑色将捕获我们的光标。这样就结束了程序的执行。

原始文件（在此太小了）： 原始来源图片

— ბიმო
source
我们从可理解的文本（例如C）过渡到难以理解的文本（例如Jelly），再过渡到图像...接下来该怎么办？：P
— frarugi87
+1我之前从未真正看到过Piet的答案，也没有做任何解释
— MilkyWay90
21

Brain-Flak，16字节

({({}[()])()}{})

在线尝试！

这是Flak 真正擅长的少数事情之一。

由于这是您可以轻松完成的最简单的操作之一，并且具有很多可见性，因此，这里有详细的解释：

# Push the sum of all of this code. In brain-flak, every snippet also returns a
# value, and all values inside the same brackets are summed
(
    # Loop and accumulate. Initially, this snippet return 0, but each time the
    # loop runs, the value of the code inside the loop is added to the result.
    {
        # Push (and also return)...
        (
            # The value on top of the stack
            {}

            # Plus the negative of...
            [
                # 1
                ()
            ]

        # The previous code pushes n-1 on to the stack and returns the value n-1
        )

        # 1
        # This code has no side effect, it just returns the value 1 each loop.
        # This effectively adds 1 to the accumulator
        ()

    # The loop will end once the value on top of the stack is 0
    }

    # Pop the zero off, which will also add 0 to the current value
    {}

# After the sum is pushed, the entire stack (which only contains the sum)
# will be implicitly printed.
)
— DJMcMayhem
source
18

Mathematica，9个字节

#(#+1)/2&

Mathematica，10个字节

(#^2+#)/2&

Mathematica，11个字节

Tr@Range@#&

Mathematica，12个字节

i~Sum~{i,#}&

Mathematica，14个字节

（@ user71546提供） 

1/2/Beta[#,2]&

Mathematica，15个字节

Tr[#&~Array~#]&

Mathematica，16个字节

Binomial[#+1,2]&

Mathematica，17个字节

（@不是树） 

⌊(2#+1)^2/8⌋&

Mathematica，18个字节

PolygonalNumber@#&

Mathematica，19个字节

#+#2&~Fold~Range@#&

Mathematica，20个字节

（@不是树）

f@0=0;f@i_:=i+f[i-1]
— J42161217
source
4
跳过13、14和17似乎很可耻……
— 不是一棵树
3
似乎是下一个挑战。...或者至少可以帮助我完成列表。
— J42161217
2
我仍然没有13或14字节的任何内容（除了只是取消了较短的答案），但是这里还有另外26个具有更大字节数的字节。
— 不是一棵树
1
@分数。在10.4上工作正常
— J42161217
1
@Notatree为您的列表，这里是35的候选者：Array[Boole[#2>=#]＆,{#,#}]~Total~2＆
— 马克S.
11

x86_64机器语言（Linux），9 8字节

0:   8d 47 01                lea    0x1(%rdi),%eax
3:   f7 ef                   imul   %edi
5:   d1 e8                   shr    %eax
7:   c3                      retq

到网上试试吧！编译并运行以下C程序。

#include<stdio.h>
const char f[]="\x8d\x47\x01\xf7\xef\xd1\xe8\xc3";
int main(){
  for( int i = 1; i<=10; i++ ) {
    printf( "%d %d\n", i, ((int(*)())f)(i) );
  }
}

感谢@CodyGray和@Peter的-1。

— 吊顶猫
source
1
您可能应该使用shr而不是sar来将输出视为未签名（代码大小不变）。（由@CodyGray发现，并在其7字节add+ loop答案中指出）。
— 彼得·科德斯
1
对于封闭格式公式的实现，这对于性能而言似乎是最佳的，但是您可以通过使用mul %edior 的单操作数形式imul %edi（每个2B）而不是3B的两操作数形式来节省字节。它使EDX的性能提高了一半，但这很好。多操作数的imul引入比单操作数形式晚，并且具有2字节操作码和0F转义字节。这三个选项中的任何一个都会在中始终产生相同的结果eax，只有高半部分取决于有符号对无符号。
— 彼得·科德斯
8

APL，3个字节

+/⍳

在线尝试！

+/-总和（减少+），⍳-范围。

— 乌里尔
source
这取决于索引。如果索引设置为0，那么您将需要额外的2个字节1+
— Werner
2
@Werner索引是默认的，1所以我没有指定。它的共同点是仅在使用时指定⎕IO←0（并且不包括在字节计数中）
— Uriel
8

Haskell，13个字节

这是最短的（我认为是这样）：

f n=sum[1..n]

在线尝试！

直接，17 13字节

f n=n*(n+1)/2

感谢@WheatWizard的-4字节！

在线尝试！

无点直接传输，15个字节

(*)=<<(/2).(+1)

感谢@nimi的想法！

在线尝试！

无点通孔sum，16字节

sum.enumFromTo 1

在线尝试！

递归22 18个字节

f 0=0;f n=n+f(n-1)

感谢@maple_shaft的创意和@Laikoni的高尔夫运动！

在线尝试！

标准fold，19字节

f n=foldr(+)0[1..n]

在线尝试！

— ბიმო
source
7

星空，27 22字节

@miles节省了5个字节！

, + +  **       +   *.

在线尝试！

说明

,             Read number (n) from STDIN and push it to the stack
 +            Duplicate top of the stack
 +            Duplicate top of the stack
  *           Pop two numbers and push their product (n*n)
*             Pop two numbers and push their sum (n+n*n)
       +      Push 2
   *          Pop two numbers and push their division ((n+n*n)/2)
.             Pop a number and print it to STDOUT
— 路易斯·门多
source
— 英里
@miles谢谢！很好的主意！
— 路易斯·门多
7

Java（OpenJDK 8），10字节

a->a++*a/2

在线尝试！

花了一点时间去打高尔夫球，n->n*(n+1)/2因为我很慢。

但这不是真正的Java答案。绝对不够详细。

import java.util.stream.*;
a->IntStream.range(1,a+1).sum()

不错，但是我们可以做得更好。

import java.util.stream.*;
(Integer a)->Stream.iterate(1,(Integer b)->Math.incrementExact(b)).limit(a).reduce(0,Integer::sum)

我爱Java。

— Xanderhall
source
1
如果您希望它更加冗长，为什么要使用lambda !？：P
— TheLethalCoder
2
我的目标是冗长的lambda，如果我想变得特别雄辩，可以写完整的程序：P
— Xanderhall
1
完全相同的解决方案已发布
— 年
2
我一定错过了，但是无论如何，我倾向于不看其他答案的内容。我更喜欢写自己的高尔夫。
— Xanderhall '17
7

检查，5个字节

:)*$p

Check甚至不是打高尔夫的语言，但它胜过CJam！

在线尝试！

说明：

输入的号码放在堆栈上。:复制它给n, n。然后以增加)，得到n, n+1。*将两者相乘，然后$将结果除以2。p打印结果，程序终止。

— 硕果累累
source
6

出租车，687字节

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l 2 r.[a]Pickup a passenger going to Addition Alley.Pickup a passenger going to The Underground.Go to Zoom Zoom:n.Go to Addition Alley:w 1 l 1 r.Pickup a passenger going to Addition Alley.Go to The Underground:n 1 r 1 r.Switch to plan "z" if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 3 l 2 l.Switch to plan "a".[z]Go to Addition Alley:n 3 l 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:n 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

在线尝试！

取消评论：

[ n = STDIN ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left 2nd right.

[ for (i=n;i>1;i--) { T+=i } ]
[a]
Pickup a passenger going to Addition Alley.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north.
Go to Addition Alley: west 1st left 1st right.
Pickup a passenger going to Addition Alley.
Go to The Underground: north 1st right 1st right.
Switch to plan "z" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 3rd left 2nd left.
Switch to plan "a".

[ print(T) ]
[z]
Go to Addition Alley: north 3rd left 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: north 1st right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.

循环字节数比使用字节数少22.6％ x*(x+1)/2

— 工程师吐司
source
5

Brainfuck，24字节。

I / O以字节为单位处理。

,[[->+>+<<]>[-<+>]<-]>>.

讲解

,[[->+>+<<]>[-<+>]<-]>>.
,                           # Read a byte from STDIN
 [                  ]       # Main loop, counting down all values from n to 1
  [->+>+<<]                 # Copy the i value to *i+1 and *i+2
           >[-<+>]          # Move *i+1 back to i
                  <-        # Move back to i, lower it by one. Because *i+2 is never reset, each iteration adds the value of i to it.
                     >>.    # Output the value of *i+2
— 阿塔科
source
2
Brainfuck在这次挑战中能够击败一些高级语言，这真是太酷了。
— GarethPW
使用您的代码在Lenguage中添加答案（只是为了好玩）对我来说是否合法？@ATaco
— V. Courtois
我不这么认为，因为它是相同的代码，只是编码方式不同。@ V.Courtois
— ATaco
@ATaco啊，你是对的。
— V. Courtois
5

,,,，6个字节

:1+×2÷

说明

:1+×2÷

:       ### duplicate
 1+     ### add 1
   ×    ### multiply
    2÷  ### divide by 2

如果我尽快实施范围...

rΣ
— 全人类
source
4

视网膜，13字节

.+
$*
1
$`1
1

在线尝试！说明：第一阶段和最后阶段只是一元⇔十进制转换。中间阶段用左边1的1s 替换每个数字，再加1上1本身的s ，从而从1到计数n，隐式地将值相加。

— 尼尔
source
4

PHP，19个字节

<?=$argn*-~$argn/2;
<?=$argn/2*++$argn;
<?=$argn*++$argn/2; # this one fails

使用内置文件，共29个字节：

<?=array_sum(range(1,$argn));

循环，31个字节：

while($argn)$s+=$argn--;echo$s;
— 提图斯
source
我猜也是：for(;$argn;$s+=$argn--);echo$s;
— Progrock
4

Cubix，12个 10字节

*,)2I://O@

初始版本

....I:)*2,O@

在线尝试！

说明

扩展到一个多维数据集，代码如下所示：

    * ,
    ) 2
I : / / O @ . .
. . . . . . . .
    . .
    . .

指令指针（IP）从处开始I，向东移动。它继续向东移动，直到穿过/镜子，再向北反射。当IP到达代码的顶部时，它绕到.第三行的最后一行，向南移动。然后，它绕到.最后一行的倒数第二个，向北移动。然后，它/再次到达镜面，该镜面向东反射，仅在下一个镜面再次/向北反射。这次，IP .在第三行包装到倒数第二个，然后在最后一行包装最后.一个。

这些指令按以下顺序执行。

I:)*2,O@ # Explanation
I        # Take input as an integer and push it to the stack
 :       # Duplicate the input
  )      # Increment one of the inputs
   *     # Multiply the input by input+1
    2    # Push 2 to the stack
     ,   # Integer devide the multiplication result by 2
      O  # Output the result
       @ # End program
— 路加
source
4

x86-64机器码，7个字节

31 C0
01 C8
E2 FC
C3

以上字节定义了一个函数，该函数接受单个参数，n并返回一个值，该值包含从1到的所有整数的和n。

它被写入Microsoft x64调用约定，该约定在ECX寄存器中传递参数。EAX像所有x86 / x86-64调用约定一样，返回值保留在中。

非高尔夫装配助记符：

       xor  eax, eax    ; zero out EAX
Next:  add  eax, ecx    ; add ECX to EAX
       loop Next        ; decrement ECX by 1, and loop as long as ECX != 0
       ret              ; return, with result in EAX

在线尝试！
（那里的C函数调用带有一个属性，该属性使GCC使用我的汇编代码使用的Microsoft调用约定对其进行调用。如果TIO提供了MSVC，则不需要这样做。）

根据代码高尔夫的不同寻常的标准，您会发现，这种迭代循环方法比使用更理智的数学公式（n(n+1) / 2）的方法更可取，尽管就运行速度而言，它显然效率低得多。

使用数论，ceilingcat的实现仍然可以被一个字节击败。上述每个指令是必要的，但有一个略短编码IMUL，使用EAX 隐式作为目的操作数（实际上，它使用EDX:EAX，但我们可以忽略的结果的高32位）。这是仅2个字节的编码，低于3个字节。

LEA也需要占用三个字节，但是实际上没有办法解决，因为我们需要在保留原始值的同时进行递增。如果我们进行了MOV制作副本，则INC将会是4个字节。（在x86-32中，这里INC只有1个字节，与3个字节相同LEA。）

最后的右移是将结果分成两半所必需的，并且肯定比乘法更紧凑（更有效）。但是，代码应该真正使用shr的，而不是sar，因为它假定输入值n，是一个无符号整数。（当然，该假设根据规则是有效的，但是如果您知道输入是无符号的，那么您就不应该进行有符号的算术移位，因为将高位设置为较大的无符号值会导致结果是不正确的。）

8D 41 01                lea    eax, [rcx+1]
F7 E9                   imul   ecx
D1 E8                   shr    eax, 1
C3                      ret

现在只有8个字节（感谢Peter Cordes）。仍然是8> 7。

— 科迪·格雷
source
1
实际上，单操作数imul ecx或mul ecx将在封闭形式的实现中工作并保存一个字节。我没有立即发现这一点。我要评论一下，在意识到隐式eax操作数很好之前，它对于性能和代码大小都是最佳的。
— 彼得·科德斯
我想知道add+ loop是否会比imul查看其他答案时更短。便捷，有这么通过了第一个参数在标准调用约定ecx
— 彼得·柯德斯
1
哇，我不敢相信我错过了单操作数表格！我现在应该真正知道不要说“无法击败”之类的话。我什么时候学？谢谢@Peter。
— 科迪·格雷
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.