เราจะใช้คำว่า "กู้หน้า" nหมายถึงการคำนวณn 2 นอกจากนี้เรายังมีการใช้คำว่า "cubing" nหมายถึงn 3 ที่ถูกกล่าวว่าทำไมเราไม่สามารถสามเหลี่ยมจำนวน?

สามเหลี่ยมเป็นอย่างไร?

• ก่อนอื่นเรามาเลือกหมายเลข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 bytes

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

ลองออนไลน์!

หลังจากแก้ไขมากตอนนี้ฉันภูมิใจในคำตอบนี้มาก ฉันชอบอัลกอริธึมและมันแสดงออกได้ดีแค่ไหนในสมอง

จำนวนไบต์ส่วนใหญ่มาจากการจัดการ 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._

ลองออนไลน์ได้ที่นี่ลองมันออนไลน์ได้ที่นี่

Nice 6 ไบต์หนึ่งที่ไม่ได้ใช้คำนำหน้า builtin:

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 มีคำตอบยอดเยี่ยมที่นี่คุณควรตรวจสอบ น่าเสียดายสำหรับเขาฉันไม่ได้ปล่อยให้เขาชนะด้วยภาษาของเขาเอง: พี

มันทำงานยังไง?

ให้เริ่มด้วยรุ่นง่าย ๆ

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

การดำเนินการหลักที่นี่คือ({}<>{})<>ที่ใช้ด้านบนของสแต็กซ้ายและเพิ่มไปที่ด้านบนของสแต็คขวา โดยการวนซ้ำการดำเนินการนี้เราจะรวมสแต็คปัจจุบัน (จนกว่าจะถึงศูนย์) วางผลรวมในสแต็กปิด นั่นเป็นเรื่องทางโลกที่น่าสนใจส่วนที่น่าสนใจคือเราสรุปผลการวิ่งทั้งหมดนี้ตามผลลัพธ์ของเรา สิ่งนี้จะคำนวณค่าที่ต้องการ ทำไม? ลองมาดูตัวอย่าง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 bytes

I just noticed that this is only really a slight golf of Business Cat's answer in the end though!

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

Try it online!

J, 7 bytes

[:+/+/\

Try it online! Takes a list of digits, such as f 6 5 4 3 2 1.

Explanation

[:+/+/\    (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

A little more true to the original problem would be [:+/@,]/, which is "sum" (+/) the flattened (,) prefixes of the input (]\).

Vim, 60 59 32 keystrokes

Thanks a lot @CowsQuack for the tip with the recursive macro and the h trick, this saved me 27 bytes!

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

Try it online!

Ungolfed/Explained

This will build the triangle like described (only that it keeps it left-aligned):

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

The buffer looks now like this:

53716
5371
537
53
5

Join all lines into one and build an evaluatable expression from it:

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

The " register now contains the following string (note missing 0):

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

So all we need to do is append a zero and evaluate it:

 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 bytes

-4 bytes thanks to Mr. Xcoder.

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

Try it online!

Takes input as a list of digits.

Bash + GNU utilities, 32 24

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

Input read from STDIN.

Update: I see the input may be given as a list of digits. My input list is newline-delimited.

Try it online.

Explanation

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 bytes

+/+\

This takes the input as a list of digits, e.g.:

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

Explanation

+/    sum of
  +\  partial sums of input

Taxi, 1478 bytes

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.

Try it online!

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 bytes

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

Try it online!

How?

$\ holds the cumulative total, $p holds the total of the digits on the current line. Each line of the parallelogram is simply the previous line with the next digit of the number appended. Therefore, it is the sum of the previous line plus the new digit. This iterates over all of the digits, calculating the sums as it goes. The actual substitution is irrelevant; it's just a means to iterate over the digits without creating an actual loop. At the end, $\ is printed implicitly by the -p option.

Python 2, 56 bytes

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

Try it online!

Jelly,  5  4 bytes

Ṛæ.J

A monadic link taking a list of decimal digits and returning the triangle of the number that list represents.

Try it online!

How?

Ṛæ.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

Retina, 13 bytes

.
$`$&
.
$*
1

Try it online! Link includes test cases. Explanation: The first stage generates all the prefixes of the original number, the second stage converts each digit to unary, and the third stage takes the total.

Mathematica, 49 bytes

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.