我们习惯于“平方” 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字节！

Σ∫

在线尝试！

“非高尔夫” /解释

Σ    -- sum all
 ∫   -- prefix sums

脑高射炮，65，50， 36个字节

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

在线尝试！

经过大量修改，我现在对此感到非常自豪。我喜欢该算法，并且可以很好地表达它。

大部分字节数来自于处理输入中的0。实际上，如果我们假设输入中没有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

在线尝试！使用与Japt答案相同的技术：累加，然后求和。

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个字节

我只是注意到，这实际上只是商务猫最后的答案！

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

原始问题更真实一些[:+/@,]/，它是输入（）+/的平化（,）前缀的“和” （]\）。

Vim，60 59 32击键

非常感谢@CowsQuack提供的有关递归宏和h技巧的提示，这为我节省了27个字节！

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

在线尝试！

取消/解释

这将像描述的那样构建三角形（只是使其保持左对齐）：

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.

在线尝试！

未打高尔夫球：

[ 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个字节

𝐗𝐂𝐬

说明：

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

在线尝试！

替代答案：

𝐗𝐣𝐬

说明：

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

在线尝试！

Java 8，53字节

我为每种可接受的输入类型实现了一个lambda。它们每个都迭代数字的数字，并将每个数字的适当倍数添加到累加器。

整数作为输入（53字节）

Lambda从Integer至Integer：

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

字符串表示形式作为输入（72字节）

Lambda从String至Integer：

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

数字数组作为输入（54字节）

Lambda从int[]（数字，最大的地方值在前）到Integer：

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

• -7字节感谢OlivierGrégoire

Pyt，9 6 字节

ąĐŁř↔·

说明：

                 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字节

感谢Xcoder先生帮助我节省了很多字节！

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

在线尝试！

将输入作为字符串。它只是将每个数字乘以需要相加的次数，然后返回它们的总和。

SNOBOL4（CSNOBOL4），79字节

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

在线尝试！

从stdin输入，输出到stdout。

Common Lisp，53 52字节

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

输入为数字列表。

在线尝试！

-1个字节感谢@ceilingcat。