Сумма всех целых чисел от 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.

Leaderboard

Запустите фрагмент кода ниже, чтобы просмотреть список лидеров для ответов на этот вопрос. (Спасибо programmer5000 и steenbergh за предложение, и Martin Ender за его создание.)



@FryAmTheEggman Извините - там был какой-то мозговой пердеть. Я понимаю, что вы имеете ввиду.
GarethPW

2
@ Аарон, ты получил ninja'd от Husk, который был только что опубликован с 1-байтовым решением
Skidsdev

7
Я предлагаю фрагмент стека.
programmer5000

Ответы:


46

Pyth , 2 байта

sS

Попробуйте онлайн! Неявный ввод. S1-индексированный диапазон и sявляется суммой.


102
Наконец, Pyth (on) код звучит как змея.
полностью человек

2
Это идеальный вызов для Пита ...
Мистер Xcoder

Я собирался ответить на это, но я думаю, что нет
Стэн Струм

32

Шелуха , 1 байт

Σ

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

Builtin! Σв Husk обычно используется для получения суммы всех элементов списка, но применительно к числу он возвращает точно n*(n+1)/2.


1
Из любопытства, происходит ли это потому, что число приводится к диапазону, а затем суммируется, или это действительно жестко закодировано?
FryAmTheEggman

4
@FryAmTheEggman это на самом деле жестко запрограммировано и похоже на поведение другой встроенной функции can, которая может вычислить произведение всех элементов списка или факториала одного числа
Лев

4
Σявляется двухбайтовым символом Unicode на моей машине. Я полагаю, вы используете кодовую страницу 1253? msdn.microsoft.com/en-us/library/cc195055.aspx
gmatht


21

Пит , 161 байт / 16 кодов

Вы можете интерпретировать его с помощью этого интерпретатора Piet или загрузить изображение на этот веб-сайт и запустить его там. Не уверен насчет количества байтов, могу ли я по-другому его кодировать, чтобы уменьшить размер.

Уменьшенная версия исходного изображения:

rapapaing-изображение

объяснение

В highlightedтексте показывает текущий стек (выращивание слева направо), предполагая , пользовательский ввод 5:

1-й переход Введите число и поместите его в стек

5

2-й переход Дублируйте этот номер в стеке

5 5

3-й переход Нажмите 1 (размер темно-красной области) на стек

5 5 1

4-й переход Добавьте два верхних числа

5 6

5-й переход Умножьте два верхних числа

30

6-й переход Черная область гарантирует, что курсор перемещается вниз прямо к светло-зеленому коделю. Этот переход толкает 2 (размер темно-зеленый) на стек

30 2

7-й переход Разделите второе число в стеке на первое

15

8-й переход Выскочить и вывести верхнее число (интерпретируется как число)

[empty]

последняя ловушка Вставляя белую область, мы получаем переход nop, черный захватывает наш курсор. Это завершает выполнение программы.

Исходный файл (здесь слишком маленький): Исходное изображение


Мы перешли от понятного текста (например, C) к неразборчивому тексту (например, Jelly) к изображениям ... Что дальше? : P
frarugi87

+1 Я на самом деле не видел ответа Пита с объяснением раньше
MilkyWay90,

21

Brain-Flak , 16 байтов

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

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

Это одна из немногих вещей, в которых умственные способности действительно хороши.

Так как это одна из самых простых вещей, которую вы можете сделать в мозговом духе, и она имеет много наглядности, вот подробное объяснение:

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


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]

4
Кажется, стыдно пропускать 13, 14 и 17 ...
Не дерево

3
Это похоже на следующий вызов ... или, по крайней мере, помогите мне завершить список.
J42161217

2
У меня до сих пор ничего нет на 13 или 14 байтов (кроме того, что я не играю в гольф ваши короткие ответы), но вот еще 26 с большим количеством байтов .
Не дерево

1
@Метки. на 10.4 отлично работает
J42161217

1
@Notatree Для вашего списка, вот кандидат на 35: Array[Boole[#2>=#]& ,{#,#}]~Total~2&
Марк С.


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.


1
Вы, вероятно, должны использовать shrвместо sar, чтобы рассматривать ваш вывод как без знака (без изменения размера кода). (Заметил @CodyGray и указал в своем 7-байтном add+ loopответе ).
Питер Кордес

1
Это выглядит оптимально для производительности в реализации формулы закрытой формы, но вы можете сохранить байт, используя форму с одним операндом mul %ediили imul %edi(каждый 2B) вместо формы с двумя операндами 3B. Он забивает EDX с высоким результатом, но это нормально. Мульти-операнд imulбыл введен позже, чем форма с одним операндом, и имеет 2-байтовый код операции с 0Fescape-байтом. Любой из трех вариантов всегда будет приводить к одному и тому же результату eax, только верхняя половина зависит от подписи против неподписания.
Питер Кордес




10

Октава , 22 19 байт

Потому что арифметические операции скучны ...

@(n)nnz(triu(e(n)))

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

объяснение

Учитывая n, это создает n× nматрицу со всеми записями, равными числу e ; делает записи ниже диагонали ноль; и выводит количество ненулевых значений.


Это на самом деле короче, чем числовая версия?
Esolanging Fruit

@ Challenger5 Нет, но числовая версия скучна:@(n)sum(1:n)
Луис Мендо



8

APL, 3 байта

+/⍳

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

+/- сумма (уменьшение +), - диапазон.


Это зависит от индексации. Если для индексации задано значение 0, то вам потребуются дополнительные 2 байта1+
Вернер

2
Индексирование @Werner по умолчанию, 1поэтому я не указал. его обычно здесь указывать только при использовании ⎕IO←0(и это не входит в число байтов)
Уриэль

8

Haskell , 13 байт

Это самое короткое ( думаю, подумалось):

f n=sum[1..n]

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

Direct, 17 13 байтов

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

Спасибо @WheatWizard за -4байты!

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

Pointfree direct, 15 байт

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

Спасибо @nimi за идею!

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

Pointfree via 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]

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


7

Звездный , 27 22 байта

5 байтов сэкономлено благодаря @miles !

, + +  **       +   *.

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

объяснение

,             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


@ Майлз Спасибо! Очень хорошая идея!
Луис Мендо

7

05AB1E , 2 байта

LO

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

Как это устроено

     #input enters stack implicitly
L    #pop a, push list [1 .. a]
 O   #sum of the list
     #implicit output 

Сумма Гаусса, 4 байта

>¹*;

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

Как это устроено

>       #input + 1
 ¹*     #get original input & multiply
   ;    #divide by two 

3
ÝOтакже работает и значит hello.
Волшебная Осьминог Урна

1
L0 и вот ..
Дилнан

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)

Я люблю Яву.


1
Если вы хотите, чтобы это было еще более многословно, зачем использовать лямбду !? : P
TheLethalCoder

2
Я стремился к многословным лямбдам, я мог бы написать полную программу, если бы я хотел быть особенно красноречивым: P
Xanderhall

1
Точно такое же решение уже было опубликовано
зима

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

7

Проверьте , 5 байтов

:)*$p

Чек даже не является языком игры в гольф, но все же превосходит CJam!

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

Объяснение:

Введенный номер помещается в стек. :дублирует это, чтобы дать n, n. Затем увеличивается с ), давая n, n+1. *умножает их вместе, а затем $делит результат на 2. pпечатает результат, и программа завершается.



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



5

Brainfuck, 24 байта.

Ввод / вывод обрабатывается как байты.

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

Разъяснения

,[[->+>+<<]>[-<+>]<-]>>.
,                           # 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

2
Довольно круто, что Brainfuck может побить некоторые языки более высокого уровня в этом испытании.
GarethPW

Это законно для меня, чтобы добавить ответ в Lenguage (просто для удовольствия), используя ваш код? @ATaco
В. Куртуа

Я так не думаю, так как это будет один и тот же код, просто закодированный по-разному. @ V.Courtois
ATaco

@ATaco Ааа, ты прав.
В. Куртуа

5

,,, 6 байт

:1+×2÷

объяснение

:1+×2÷

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

Если я реализую диапазон в ближайшее время ...


4

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

.+
$*
1
$`1
1

Попробуйте онлайн! Пояснение: Первый и последний этапы - это просто одинарное ⇔ десятичное преобразование. Средняя ступень заменяет каждую 1на число 1s слева от нее плюс другую 1для самого 1себя, таким образом, считая от 1до n, суммируя значения неявно.




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;

Я думаю, что тоже: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

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), хотя он, очевидно, значительно менее эффективен с точки зрения скорости выполнения.

Используя теорию чисел, реализация потолочной системы все еще может быть побита одним байтом. Каждая из этих инструкций важна, но есть немного более короткая кодировка, в 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 байтов (спасибо Петру Кордесу). Тем не менее, 8> 7.


1
На самом деле, один операнд imul ecxили mul ecxбудет работать и сохранить байт в реализации закрытой формы. Я не сразу заметил это; Я собирался прокомментировать, что это было оптимально как для производительности, так и для размера кода, прежде чем я понял, что неявный eaxоперанд в порядке.
Питер Кордес

Я задавался вопросом, будет ли add+ loopкороче, чем imulпри взгляде на другой ответ. Удобно, что есть стандартное соглашение о вызовах, которое передает первый аргументecx
Питер Кордес

1
Вау, я не могу поверить, что пропустил форму с одним операндом! Я должен действительно знать, чтобы не говорить такие вещи, как «не может быть побежден». Когда я буду учиться ?! Спасибо, @Peter.
Коди Грей,
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.