Мы привыкли к термину «возведение в квадрат» n, чтобы означать вычисление n ² . Мы также привыкли к тому, что термин «куб» n означает n ³ . При этом, почему мы не можем также треугольник число?

Как треугольник номер?

• Прежде всего, давайте выберем номер 53716.

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

      53716
     53716
    53716
   53716
  53716
  

• Теперь мы хотим это, верно? Для этого обрежьте стороны, которые не вписываются в прямоугольный треугольник:

      5
     53
    537
   5371
  53716
  

• Возьмем суммы каждой строки, для этого примера, в результате чего [5, 8, 15, 16, 22]:

      5 -> 5
     53 -> 8
    537 -> 15
   5371 -> 16
  53716 -> 22
  

• Подводить список [5, 8, 15, 16, 22], в результате чего 66. Это треугольник этого числа!

Спецификации и правила

• Входными данными будет неотрицательное целое число n ( n ≥ 0, n ∈ Z ).

• Вы можете принимать входные данные и предоставлять выходные данные любым разрешенным способом .

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

• По умолчанию лазейки запрещены.

• Это код-гольф , поэтому выигрывает самый короткий код в байтах!

Больше тестов

Вход -> Выход

0 -> 0
1 -> 1
12 -> 4
123 -> 10
999 -> 54 
100000 -> 6
654321 -> 91

Вдохновение. Пояснения приветствуются!

Haskell , 13 байт

sum.scanl1(+)

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

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

Шелуха , 4̷ 2 байта

Спасибо @ H.PWiz за -2байты!

Σ∫

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

"Ungolfed" / Разъяснения

Σ    -- sum all
 ∫   -- prefix sums

Brain-Flak , 65, 50, 36 байтов

([])({<{}>{<({}[()])>[]}{}<([])>}{})

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

После многих пересмотров я теперь очень горжусь этим ответом. Мне нравится алгоритм, и как хорошо он может быть выражен в мозге.

Большая часть подсчета байтов получается при обработке 0 на входе. Фактически, если бы мы могли предположить, что на входе не было нулей, это был бы красивый короткий 20-байтовый ответ:

({{<({}[()])>[]}{}})

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

Но, к сожалению, мозговые штурмы печально известны плохой обработкой крайних случаев.

объяснение

Во-первых, мое наблюдение:

Если длина ввода n цифр, первая цифра появится в треугольнике n раз, вторая цифра появится n-1 раз, и так далее до последней цифры, которая появится один раз. Мы можем воспользоваться этим, так как действительно легко вычислить, сколько цифр ввода осталось в мозговом штурме, а именно

[]

Итак, вот как работает код.

# Push the size of the input (to account for 0's)
([])

# Push...
(

    # While True
    {

        # Pop the stack height (evaluates to 0)
        <{}>

        # For each digit *D*...

        # While true
        {

            # Decrement the counter (the current digit we're evaluating), 
            # but evaluate to 0
            <({}[()])>

            # Evaluate the number of digits left in the input
            []

        # Endwhile
        }

        # This whole block evaluates to D * len(remaining_digits), but 
        # without affecting the stack

        # Since we looped D times, D is now 0 and there is one less digit.
        # Pop D (now 0)
        {}

        # Push the stack height (again, evaluating it as 0)
        <([])>

    # End while
    }

    # Pop a 0 off (handles edge case of 0)
    {}

# end push
)

Pyth - 6 4 байта

ss._

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

Хороший 6-байтовый, который не использует встроенный префикс:

s*V_Sl

MATL , 3 байта

Yss

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

Принимает ввод в виде списка цифр.

Желе , 3 байта

+\S

Попробуйте онлайн! Использует ту же технику, что и мой ответ Япта: кумулятивное сложение, затем сумма.

Haskell , 25 байт

Принимает ввод как список цифр

f[]=0
f x=sum x+f(init x)

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

Haskell , 41 байт

Принимает ввод как строковое представление

f[]=0
f x=sum(map(read.(:[]))x)+f(init x)

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

Japt , 7 6 4 байта

å+ x

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

объяснение

å+ x    Implicit: input = digit list
å+      Cumulative reduce by addition. Gives the sum of each prefix.
   x    Sum.

Старое решение:

å+ ¬¬x

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

объяснение

å+ ¬¬x   Implicit: input = string
å+       Cumulative reduce by concatenation. Gives the list of prefixes.
   ¬     Join into a single string of digits.
    ¬    Split back into digits.
     x   Sum.
         Implicit: output result of last expression

Brain-Flak , 28 байт

(([]){[{}]({}<>{})<>([])}{})

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

14 байтов, если нам не нужно поддерживать нули (что мы делаем)

({({}<>{})<>})

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

У DJMcMayhem классный ответ здесь вы должны проверить. К сожалению для него, я не собирался позволять ему побеждать на его родном языке: P

Как это работает?

Начнем с простой версии.

({({}<>{})<>})

Основное действие здесь состоит в том ({}<>{})<>, что он берет вершину левого стека и добавляет к вершине правого стека. Зацикливая эту операцию, мы суммируем текущий стек (пока он не достигнет нуля), помещая сумму в стек выключения. Это довольно обыденно, интересная часть в том, что мы подводим итоги всех этих запусков как наш результат. Это рассчитает желаемое значение. Зачем? Хорошо, давайте посмотрим на пример 123. При первом захвате мы просто получаем 1, поэтому наше значение равно 1

1

На следующем захвате мы возвращаем 1 плюс 2

1
1+2

На последнем забеге мы все трое вместе

1
1+2
1+2+3

Ты видишь треугольник? Сумма всех прогонов является «треугольником» списка.

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

([])({<{}>({}<>{})<><([])>}{})

Затем я воспользовался этим советом , написанным никем иным, кроме вас, чтобы отыграть еще 2 байта.

(([]){[{}]({}<>{})<>([])}{})

И там у нас это есть. Я был бы удивлен, если бы было более короткое решение, но затем снова произошли более странные вещи.

JavaScript (ES6), 28 байт

a=>a.map(d=>t+=c+=d,t=c=0)|t

Вводит в виде списка цифр.

Python 3 , 37 байт

f=lambda n:len(n)and sum(n)+f(n[:-1])

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

C # (.NET Core) , 59 байт

using System.Linq;N=>N.Reverse().Select((d,i)=>i*d+d).Sum()

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

Существенно отличается от других ответов C #. Ввод представляет собой список цифр. Все тестовые примеры включены в ссылку TIO.

Может сохранить несколько байтов, если разрешено принимать входные данные в виде обратного списка цифр с начальным 0.

Python 3 , 35 байт

Я только что заметил, что это всего лишь небольшая доля ответа Business Cat в конце концов!

f=lambda a:a>[]and sum(a)+f(a[:-1])

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

J 7 байт

[:+/+/\

Попробуйте онлайн! Принимает список цифр, таких какf 6 5 4 3 2 1 .

объяснение

[:+/+/\    (for explanation, input = 6 5 4 3 2 1)
      \    over the prefixes of the input:
     /         reduce:
    +              addition (summation)
           this gives is the cumulative sum of the input:  6 11 15 18 20 21
[:         apply to the result:
  +/           summation
           this gives the desired result:   90

Чуть более верной была бы исходная проблема [:+/@,]/: «sum» +/( ,) префиксы flatlined ( ) для input ( ]\).

Вим , 60 59 32 нажатия клавиш

Большое спасибо @CowsQuack за подсказку с рекурсивным макросом и hтрюком, это сэкономило мне 27 байт!

qqYp$xh@qq@qVHJ:s/./&+/g⏎
C<C-r>=<C-r>"0⏎

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

Ungolfed / Разъяснения

Это создаст треугольник, как описано (только если он будет выровнен по левому краю):

qq       q    " record the macro q:
  Yp          "   duplicate the line
    $x        "   remove last character
      h       "   move to the left (this is solely that the recursive macro calls stop)
       @q     "   run the macro recursively
          @q  " run the macro

Буфер теперь выглядит так:

53716
5371
537
53
5

Объедините все строки в одну и создайте из нее вычисляемое выражение:

VH             " mark everything
  J            " join into one line
   :s/./&+/g⏎  " insert a + between all the characters

"Регистр теперь содержит следующую строку (примечание отсутствует 0):

5+3+7+1+6+ +5+3+7+1+ +5+3+7+ +5+3+ +5+ +

Итак, все, что нам нужно сделать, это добавить ноль и оценить его:

 C                " delete line and store in " register
  <C-r>=       ⏎  " insert the evaluated expression from
        <C-r>"    " register "
              0   " append the missing 0

Python 2 , 49 45 байт

-4 байта благодаря мистеру Xcoder.

lambda n:sum(-~i*n[~i]for i in range(len(n)))

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

Вводит в виде списка цифр.

Утилиты Bash + GNU, 32 24

tac|nl -s*|paste -sd+|bc

Ввод читать из STDIN.

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

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

объяснение

tac                       # reverse digit list
   |nl -s*                # prefix line numbers; separate with "*" operator
          |paste -sd+     # join lines onto one line, separated with "+" operator
                     |bc  # arithmetically evaluate

APL, 4 байта

+/+\

Это принимает входные данные в виде списка цифр, например:

      (+/+\) 5 3 7 1 6
66

объяснение

+/    sum of
  +\  partial sums of input

Такси , 1478 байт

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 1 r 1 l 4 r 1 l.[a]Switch to plan "b" if no one is waiting.Pickup a passenger going to The Babelfishery.Go to Zoom Zoom:n 1 l 3 r.1 is waiting at Starchild Numerology.Go to Starchild Numerology:w 4 l 2 r.Pickup a passenger going to Addition Alley.Go to Addition Alley:w 1 r 3 r 1 r 1 r.Pickup a passenger going to Addition Alley.Go to The Babelfishery:n 1 r 1 r.Go to Chop Suey:n 6 r 1 l.Switch to plan "a".[b]Go to Addition Alley:n 1 l 2 l.Pickup a passenger going to Cyclone.[c]Go to Zoom Zoom:n 1 l 1 r.Go to Cyclone:w.Pickup a passenger going to The Underground.Pickup a passenger going to Multiplication Station.Go to The Babelfishery:s 1 l 2 r 1 r.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:n 1 r 2 l.Pickup a passenger going to Addition Alley.Go to The Underground:n 2 l 1 r.Switch to plan "d" if no one is waiting.Pickup a passenger going to Cyclone.Go to Addition Alley:n 3 l 1 l.Switch to plan "c".[d]Go to Addition Alley:n 3 l 1 l.[e]Pickup a passenger going to Addition Alley.Go to Zoom Zoom:n 1 l 1 r.Go to Addition Alley:w 1 l 1 r.Pickup a passenger going to Addition Alley.Switch to plan "f" if no one is waiting.Switch to plan "e".[f]Go to Zoom Zoom:n 1 l 1 r.Go to Addition Alley:w 1 l 1 r.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.

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

Un-golfed:

[ Pickup stdin and split into digits ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 1st right 1st left 4th right 1st left.
[a]
[ Count the digits ]
Switch to plan "b" if no one is waiting.
Pickup a passenger going to The Babelfishery.
Go to Zoom Zoom: north 1st left 3rd right.
1 is waiting at Starchild Numerology.
Go to Starchild Numerology: west 4th left 2nd right.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: west 1st right 3rd right 1st right 1st right.
Pickup a passenger going to Addition Alley.
Go to The Babelfishery: north 1st right 1st right.
Go to Chop Suey: north 6th right 1st left.
Switch to plan "a".
[b]
Go to Addition Alley: north 1st left 2nd left.
Pickup a passenger going to Cyclone.
[c]
[ Multiply each digits by Len(stdin)-Position(digit) ]
Go to Zoom Zoom: north 1st left 1st right.
Go to Cyclone: west.
Pickup a passenger going to The Underground.
Pickup a passenger going to Multiplication Station.
Go to The Babelfishery: south 1st left 2nd right 1st right.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: north 1st right 2nd left.
Pickup a passenger going to Addition Alley.
Go to The Underground: north 2nd left 1st right.
Switch to plan "d" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Addition Alley: north 3rd left 1st left.
Switch to plan "c".
[d]
Go to Addition Alley: north 3rd left 1st left.
[e]
[ Sum all the products ]
Pickup a passenger going to Addition Alley.
Go to Zoom Zoom: north 1st left 1st right.
Go to Addition Alley: west 1st left 1st right.
Pickup a passenger going to Addition Alley.
Switch to plan "f" if no one is waiting.
Switch to plan "e".
[f]
[ Output the results ]
Go to Zoom Zoom: north 1st left 1st right.
Go to Addition Alley: west 1st left 1st right.
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.

Perl 5 , 19 + 1 ( -p) = 20 байт

s/./$\+=$p+=$&/ge}{

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

Как?

$ \ содержит кумулятивную сумму, $ p содержит сумму цифр в текущей строке. Каждая строка параллелограмма - это просто предыдущая строка с добавленной следующей цифрой числа. Следовательно, это сумма предыдущей строки плюс новая цифра. Это перебирает все цифры, вычисляя суммы по ходу дела. Фактическая замена не имеет значения; это просто средство для перебора цифр без создания реального цикла. В конце $ \ печатается неявно с помощью -pопции.

Python 2 , 56 байт

lambda x:sum(i*int(`x`[-i])for i in range(1,1+len(`x`)))

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

Желе ,  5  4 байта

Ṛæ.J

Монадическая ссылка, принимающая список десятичных цифр и возвращающая треугольник числа, представленного в списке.

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

Как?

Ṛæ.J - Link: list of numbers (the decimal digits), d   e.g. [9,4,5,0]
Ṛ    - reverse d                                            [0,5,4,9]
   J - range(length(d))                                     [1,2,3,4]
 æ.  - dot-product            (0*1 + 5*2 + 4*3 + 9*4 = 58)  58

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

.
$`$&
.
$*
1

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

Mathematica, 49 байтов

Tr@Array[Tr@s[[;;#]]&,Length[s=IntegerDigits@#]]&

Neim, 3 bytes

𝐗𝐂𝐬

Explanation:

𝐗        Get prefixes of input, including itself
 𝐂       Implicitly join elements together, and create an array with all the digits
  𝐬      Sum

Try it online!

Alternative answer:

𝐗𝐣𝐬

Explanation:

𝐗       Get prefixes of input, including itself
 𝐣       Join
  𝐬      Implicitly convert to a digit array, and sum

Try it online!

Java 8, 53 bytes

I implemented a lambda for each acceptable input type. They each iterate through the number's digits, adding the proper multiple of each to an accumulator.

Integer as input (53 bytes)

Lambda from Integer to Integer:

n->{int s=0,i=1;for(;n>0;n/=10)s+=n%10*i++;return s;}

String representation as input (72 bytes)

Lambda from String to Integer:

s->{int l=s.length(),n=0;for(int b:s.getBytes())n+=(b-48)*l--;return n;}

Digit array as input (54 bytes)

Lambda from int[] (of digits, largest place value first) to Integer:

a->{int l=a.length,s=0;for(int n:a)s+=n*l--;return s;}

• -7 bytes thanks to Olivier Grégoire

Pyt, 9 6 bytes

ąĐŁř↔·

Explanation:

                 Implicit input
ą                Convert to array of digits
 Đ               Duplicate digit array
   Łř↔           Create a new array [len(array),len(array)-1,...,1]
      ·          Dot product with digit array
                 Implicit output

Python 3, 94 58 54 bytes

Thanks to Mr. Xcoder for helping me save quite some bytes!

lambda n:sum(int(v)*(len(n)-i)for i,v in enumerate(n))

Try It Online!

Takes input as a string. It simply multiplies each digit by the number of times it needs to be added and returns their sum.

SNOBOL4 (CSNOBOL4), 79 bytes

	N =INPUT
D	N LEN(1) . D REM . N	:F(O)
	X =X + D
	Y =Y + X	:(D)
O	OUTPUT =Y
END

Try it online!

Input from stdin, output to stdout.

Common Lisp, 53 52 bytes

(loop as(x . y)on(reverse(read))sum(+(reduce'+ y)x))

Input as list of digits.

Try it online!

-1 byte thanks to @ceilingcat.