เอาไปรวมกันจริงๆ

เขียนโปรแกรมหรือฟังก์ชั่นที่รับรายการเลขจำนวนเต็มฐานสิบ (0-9) ที่ไม่มีข้อยกเว้นและส่งออก "สามเหลี่ยม" ที่ชี้ลงของตัวเลขพร้อมรายการอินพุตที่ด้านบนซึ่งทุกหลักหลังจากบรรทัดแรกคือผลรวมของตัวเลขสองหลัก ด้านบนมันโมดูโล 10

ตัวอย่างเช่นอินพุต[7, 5, 0, 9]มีเอาต์พุต

7 5 0 9
 2 5 9
  7 4
   1

เพราะ2เป็น(7 + 5) mod 10, 5คือ(5 + 0) mod 10, 9เป็น(0 + 9) mod 10เป็นต้นไปทางความเป็นอยู่1(7 + 4) mod 10

หากรายการมีเพียงหนึ่งรายการดังนั้นผลลัพธ์จะตรงกับอินพุต เช่นการป้อนข้อมูลของความ[4]ประสงค์

4

นี่คือตัวอย่างเพิ่มเติม:

[0]

0

[1, 2]

1 2
 3

[8, 7]

8 7
 5

[0, 0]

0 0
 0

[1, 4, 2]

1 4 2
 5 6
  1

[0, 1, 0]

0 1 0
 1 1
  2

[1, 0, 0, 0]

1 0 0 0
 1 0 0
  1 0
   1

[1, 2, 3, 4]

1 2 3 4
 3 5 7
  8 2
   0

[1, 2, 3, 5, 8]

1 2 3 5 8
 3 5 8 3
  8 3 1
   1 4
    5

[9, 2, 4, 5, 3, 2, 2]

9 2 4 5 3 2 2
 1 6 9 8 5 4
  7 5 7 3 9
   2 2 0 2
    4 2 2
     6 4
      0

โปรดทราบว่าในการส่งออก:

• บรรทัดแรกไม่มีช่องว่างนำหน้า
• แต่ละบรรทัดถัดมามีพื้นที่นำหน้ามากกว่าหนึ่งบรรทัดก่อนหน้านี้
• ตัวเลขจะถูกคั่นด้วยช่องว่างเดียว
• แต่ละบรรทัดอนุญาตให้มีพื้นที่ต่อท้ายได้สูงสุดหนึ่งรายการ
• อาจมีบรรทัดใหม่ต่อท้ายที่เป็นตัวเลือกเดียว
• คุณต้องใช้ตัวอักษรสำหรับเลขทศนิยมปกติ (0 ถึง 9)

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ Tiebreaker เป็นคำตอบก่อนหน้า

BrainF ** k, 396 391 ไบต์

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

ฉันไม่สามารถต้านทานสิ่งล่อใจที่จะทำสิ่งนี้ อย่างน้อยรูปสามเหลี่ยมนั้นคือด้านที่แหลมลง

อินพุตเข้ามาเป็นสตริงของอักขระตัวเลขตามด้วยบรรทัดใหม่หนึ่งบรรทัด

เอาต์พุตจะมีช่องว่างต่อท้ายหนึ่งช่องในทุกบรรทัด

ตัวอย่าง:

$ bf sd.bf
010
0 1 0 
 1 1 
  2 

$ bf sd.bf
123456
1 2 3 4 5 6 
 3 5 7 9 1 
  8 2 6 0 
   0 8 6 
    8 4 
     2 

$ bf sd.bf
9245322
9 2 4 5 3 2 2 
 1 6 9 8 5 4 
  7 5 7 3 9 
   2 2 0 2 
    4 2 2 
     6 4 
      0 

คำอธิบาย

เนื่องจากมันค่อนข้างยากที่จะอธิบายโค้ดจากมุมมองของการทำงานเราจึงสามารถดูได้จากมุมมองของสถานะของเทปในหลาย ๆ ครั้ง แนวคิดหลักที่นี่คือสามเหลี่ยมที่เราส่งออกนั้นเริ่มต้นเป็นอาร์เรย์ที่บรรจุแน่น (สำหรับ BF แล้ว) ที่หดขนาดโดย 1 ทุกการวนซ้ำของลูป ความคิดที่สำคัญอีกประการหนึ่งคือเราใช้255เพื่อระบุ "ตัวยึด" ที่เราสามารถค้นหาบนเทป

การเริ่มต้น

นี่เป็นขั้นตอนที่ง่ายที่สุด เมื่อเริ่มต้นโปรแกรมเราจะดำเนินการดังต่อไปนี้:

>+>>++++[-<++++++++>]->

สิ่งนี้บังคับให้เทปอยู่ในสถานะต่อไปนี้ (โดยที่>N<ระบุตำแหน่งของตัวชี้บนเทป)

[ 0 1 32 255 >0< 0 0 ...]

หมายเลขแรกที่นี่คือตำแหน่ง "บัฟเฟอร์" เราจะไม่ใช้มันในระยะยาว แต่มันมีประโยชน์ที่จะทำให้การดำเนินงานเล็ก ๆ น้อย ๆ ง่ายขึ้นและสำหรับการคัดลอกข้อมูล
ตัวเลขที่สองคือจำนวนของช่องว่างที่เราจะ outputting ในช่วงเริ่มต้นของแต่ละบรรทัดที่เริ่มต้นหลังจากบรรทัดแรก บรรทัดแรกจะไม่มีช่องว่างนำหน้า
หมายเลขที่สามคืออักขระช่องว่างที่เราส่งออก
ตัวเลขที่สี่คือตัวยึด 255 เพื่อให้เราสามารถกลับมาที่ตำแหน่งนี้ได้อย่างง่ายดาย

อินพุต

จากตำแหน่งนี้เราจะอ่านตัวละครทุกตัว ในตอนท้ายของขั้นตอนนี้เราหวังว่าจะอยู่ในสถานการณ์ต่อไปนี้:

[ 0 1 32 255 a b c d e f ... >255< 0 0 ... ]

โดยที่a b c d e f ...ระบุสตริงของอักขระตัวเลขที่เป็นอินพุต (ไม่ใช่บรรทัดใหม่)

เราทำสิ่งนี้สำเร็จด้วยสิ่งต่อไปนี้:

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

มีความแตกต่างเล็กน้อยในเรื่องนี้ ก่อนอื่นเราจะเอาท์พุทตัวละครแต่ละตัวเมื่อเราได้พวกมันออกมาแล้วเว้นวรรคหลังจากนั้น ประการที่สองเราไม่ต้องการคัดลอกค่า ASCII ไปยังเทปเราต้องการคัดลอกตัวเลขที่แท้จริง ประการที่สามเราต้องการหยุดเมื่อเราตีขึ้นบรรทัดใหม่และปล่อยให้ตัวเองอยู่ในสถานที่ที่ดีในเวลานั้น บอกว่าการป้อนข้อมูลของเราคือ
6723จากนั้นเมื่ออ่านครั้งแรก6เทปของเราจะเป็นดังนี้:

[ 0 1 32 255 >54< 0 0 ...]

เราตรวจสอบว่าค่านี้ไม่เท่ากับ10(คำขึ้นบรรทัดใหม่ ASCII) ,----------[++++++++++ด้วย จากนั้นเราพิมพ์ค่าออกมาและดำเนินการต่อโดยการลบ 48 จากค่าอินพุตและเพิ่ม 32 ไปยังค่าถัดจาก (พร้อมกัน>>++++++++[-<++++<------>>]<) ทิ้งเราไว้ที่นี่:

[ 0 1 32 255 6 >32< 0 ...]

แจ้งให้ทราบว่าตลอดกระบวนการนี้เราสามารถสรุปได้ว่าตัวเลขทั้งหมดทางด้านขวาของการป้อนข้อมูลของเรามี 0 - ที่นี้หมายถึงว่าเราไม่ได้อยู่ในอันตรายจากการทำลายของรัฐก่อนหน้านี้ถ้าเราใช้ค่าไปทางขวาเพื่อคำนวณและ6 * 8 ตอนนี้เราแสดงอักขระอวกาศที่เราเพิ่งสร้างขึ้นและรับข้อมูลใหม่ลบพื้นที่ที่เราคำนวณไป ในที่สุดอินพุตจะถูกยกเลิกโดยบรรทัดใหม่และลูปจะออกจากไปโดยที่บรรทัดใหม่จะเป็น ( ) นี่คือตัวยึดตำแหน่งที่สองที่เราจะใช้นำทางเทป ณ จุดนี้ในสถานการณ์ของเราเทปของเราตรงนี้:4 * 8
255,----------]-

[ 0 1 32 255 6 7 2 3 >255< 0 0 ... ]

การคำนวณ

วิธีการทำงานนี้คือรายการของตัวเลขระหว่าง255ตัวยึดตำแหน่งของเราจะลดลงหนึ่งรอบทุกรอบของการวนซ้ำ เมื่อมันเหลือเพียง 1 หลักเราก็เสร็จแล้วและควรจะหยุดทันที (โปรดทราบว่า ณ จุดนี้ทุกหลักในรายการนั้นได้รับการส่งออกแล้วดังนั้นเราไม่ต้องกังวลเกี่ยวกับการแสดงผลอีกครั้ง)

ขณะนี้เราใช้เคล็ดลับนี้เพื่อนำทางไปยังคนแรกที่ยึด:255 <+[-<+]-วิธีนี้จะทำการค้นหาเทปทางด้านซ้ายเพื่อหา a 255โดยไม่ต้องเปลี่ยนอะไร ตอนนี้เราได้ย้ายตัวชี้เราสามารถตรวจสอบสภาพทางออกของเรา: 255ถ้ามีเพียงหนึ่งหลักในรายการแล้วเซลล์สองช่องว่างด้านขวาจะถือ ดังนั้นเราตรวจสอบกับสิ่งนั้นและเริ่มวนซ้ำ:>>+[-<<

ขั้นตอนแรกในการวนซ้ำของเราคือการแสดงบรรทัดใหม่ ดังนั้นเราย้ายไปที่เซลล์แรก (เซลล์บัฟเฟอร์ของเรา) เพิ่ม 10 เข้าไปและส่งออก ขั้นตอนต่อไปคือการแสดงผลอักขระช่องว่างทั้งหมด หลังจากเอาท์พุทพวกเราเพิ่มจำนวนของเราสำหรับจำนวนของช่องว่างนำ ขั้นตอนเหล่านี้สามารถทำได้โดยทำดังต่อไปนี้:

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

ซึ่งทำให้เราอยู่ในสถานะนี้:

[ 0 2 32 255 >6< 7 2 3 255 0 0 0 0 0 0 ]

ขั้นตอนต่อไปของเราคือการคัดลอกค่าแรกในรายการผ่านตัวยึดตำแหน่งที่สอง255:

[[->+]->>+<<<+[-<+]->]

เราทำสิ่งนี้โดยการกระโดดไปมาระหว่างตัวยึดตำแหน่งของเรา255และปล่อยให้เราอยู่ที่นี่:

[ 0 2 32 255 >0< 7 2 3 255 0 6 0 0 ... ]

ตอนนี้เราเริ่มวนซ้ำวนซ้ำส่วนที่เหลือของรายการหยุดเมื่อเรากด255:>+[-<

ณ จุดนี้ตัวเลขทางด้านซ้ายมือของเราอยู่เสมอ 0 ดังนั้นเนื่องจากเรารักพวกเขาเราจึงมีตัวยึดตำแหน่ง255ในนั้นเพื่อให้เราสามารถกลับมาที่สถานที่ของเราในรายการ 255ขั้นตอนต่อไปคือการย้ายสถานที่ที่สองในรายการไปยังสถานที่โดยรอบที่เราย้ายสถานที่แรกที่ผ่านมายึดตำแหน่งที่สอง ขั้นตอนเหล่านี้สามารถทำได้โดยทำดังต่อไปนี้:

->
[[->+]->+>>+<<<<+[-<+]->]

ออกจากเราที่นี่: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] ตอนนี้ทั้งสอง6และ7ถูกย้ายไปยังสถานที่ที่การคำนวณสามารถเกิดขึ้นได้ เราต้องการสำเนาสองชุด7เพราะหมายเลขถัดไปในรายการจะต้องใช้เช่นกัน 7ทันทีหลังจากที่255มีจุดมุ่งหมายนี้ในขณะที่คนอื่น ๆ7จะได้รับการบริโภคโดยการคำนวณ

อันดับแรกเราเพิ่มตัวเลขสองหลัก:

<+>->+[->+]->>
[->+<]>

ออกจากเราที่นี่:

[ 0 2 32 255 0 255 2 3 255 7 0 >13< 0 ]

การรวมกันของขั้นตอนต่อไปนั้นซับซ้อนที่สุด เราจำเป็นต้องดูว่าตัวเลขที่เรากำลังชี้ไปที่มีขนาดใหญ่กว่า 10 10และถ้ามันเป็นเราลบ ในความเป็นจริงสิ่งที่เราทำคือเราลบ 10 จากมันและดูว่ามันกระทบ0ที่จุดใด ๆ ในการลบหรือไม่ ถ้าเป็นเช่นนั้นเราจะเพิ่ม10ในภายหลัง ในตอนท้ายของเรื่องนี้เราควรจะมีผลรวมโมดูโล 10

Prepare a 10 to the right
+>++++++++++
Leave yet another 255 for a loop condition later
>>-<<
If the number is greater than 10 end up one space to the left
else one space to the right
[-<-[>>]<]<->
Check if the previous 255 is two spaces to the right and if it is
add 10 back to our sum--we've subtracted too much
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

เมื่อมาถึงจุดนี้เราได้บรรลุเป้าหมาย เรามีโมดูโล่รวม 10! นอกจากนี้ไม่ว่าจำนวนจะมากกว่า 10 เราจะสิ้นสุดที่นี่:

[ 0 2 32 255 0 255 2 3 255 7 0 3 0 0 >0< ]

เป้าหมายต่อไปของเราคือการแสดงผลรวมใหม่นี้ตามด้วยช่องว่างแล้วอัดกลับเข้าไปในรายการของเรา เราทำสิ่งนี้ด้วยเทคนิคก่อนหน้าของเราในการ255กระโดดและเพิ่ม48เข้าไปในผลรวมของเราดังนั้นฉันจะไม่ครอบคลุมในรายละเอียด

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

และเราอยู่ที่นี่: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] สังเกตว่าเราใส่255ตัวยึดตำแหน่งเพิ่มเติมหลังจากที่ถูกแทรกใหม่3เพื่อไม่ให้สูญเสียตำแหน่งในรายการ ณ จุดนี้เรามีผลรวมของเราและพื้นที่ของมันดังนั้นเราจึงจำเป็นต้องทำความสะอาดและเปลี่ยนกลับสู่สถานะที่การวนซ้ำครั้งถัดไปของลูปนี้จะทำงาน เราจำเป็นต้องล้างออก51และ32เซลล์ของเราย้าย7ครั้งเดียวไปทางขวาและนำทางไปยังตัวยึดตำแหน่งรายการของเราเพื่อให้เราสามารถเริ่มต้นใหม่

[-]<[-]<<<[->+<]<<+[-<+]

ตอนนี้เราอยู่ที่นี่: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
ซึ่งเป็นสิ่งที่เราต้องการสำหรับการทำซ้ำต่อไปของเรา ดังนั้นตรวจสอบ 255 และไป! ( >+])

เมื่อเราหลุดออกจากวงเราจะมีรายการใหม่ทั้งหมด - ประกอบด้วยจำนวนเงินจากรายการก่อนหน้า ครั้งแรกมันจะเป็นดังนี้:

 [ 0 2 32 255 3 9 5 0 >0< ]

ตอนนี้เราต้องการทำซ้ำกระบวนการทั้งหมดในรายการใหม่ของเราดังนั้นเราจึง255ลงไปทางซ้ายและเริ่มใหม่! เราต้องทำความสะอาดนิดหน่อย>>[-]<<แล้วก็วางตัวแทนของเราลง<-ไป หลังจากนั้นเราก็อยู่ในสถานที่เดียวกันกับที่เราป้อนข้อมูลดังนั้นเราสามารถออกไปทำเช็คเดียวกัน: <+[-<+]->>+และบูม! เราได้วนเต็มแล้ว! ]ทั้งหมดที่เราต้องการคือวงเล็บปิดและเมื่อมันจบแล้วเราได้ทุกอย่างที่ออกเพื่อให้เราดำเนินการเสร็จแล้ว:

เยลลี่ , 20 19 18 ไบต์

Ṛ+2\Ṗп%⁵z”@ṚZGḟ”@

ลองออนไลน์!

พื้นหลัง

การสร้างตัวเลขนั้นตรงไปตรงมาใน Jelly ผลลัพธ์มีความซับซ้อนขึ้นเล็กน้อย

เจลลี่มีกริดอะตอมในตัว ( G) ที่แสดงรายการ 2D พร้อมการขึ้นบรรทัดใหม่ระหว่างแถวและช่องว่างระหว่างคอลัมน์ เราใช้อาร์เรย์ 2 มิติของตัวเลข (สร้างขึ้นด้วยแต่ละแถวกลับรายการ) @และย้ายมันมีมูลค่าการเติม หลังจากคืนค่าอาร์เรย์ผลลัพธ์และ transposing อีกครั้งให้ใช้Gอัตราผลตอบแทนต่อไปนี้

9 2 4 5 3 2 2
@ 1 6 9 8 5 4
@ @ 7 5 7 3 9
@ @ @ 2 2 0 2
@ @ @ @ 4 2 2
@ @ @ @ @ 6 4
@ @ @ @ @ @ 0

เพื่อให้ได้รูปสามเหลี่ยมที่ต้องการสิ่งที่เราต้องทำคือลบค่าการเติม

มันทำงานอย่างไร

Ṛ+2\Ṗп%⁵z”@ṚZGḟ”@  Main link. Argument: A (list of integers)

Ṛ                   Reverse A.
    Ṗп             While there's more than one element:
 +2\                  Compute the pairwise sum.
                    Collect all intermediate results in a list.
       %⁵           Take all resulting integers modulo 10.
         z”@        Transpose with fill value '@'.
            Ṛ       Reverse the order of the rows.
             Z      Transpose.
              G     Grid.
               ḟ”@  Filter; remove the fill value.

Pyth - 18 ไบต์

j.e+*dkjdbP.ueM+Vt

Test Suite

j                                       Join by newlines
 .e                                     Loop over seq in var b and index in var k
  +                                     Concatenate
   *dk                                  Space repeated k times
    jdb                                 Join b by spaces
  P                                     [:-1] to get rid of empty line
   .u             (Q implicit)          Cumulative fixed point over input (var G)
    eM                                  Mod 10 mapped over list
     +V                                 Vectorized addition
      t(G implict)                      G[1:]
      (G implict)                       Vectorize cuts this off to G[:-1]

Python 3.5, 74 72 71 ไบต์

f=lambda L,*S:f([sum(x)%10for x in zip(L,L[1:print(*S,*L)]or 1)],'',*S)

อินพุตคือรายการจำนวนเต็ม (เช่นf([1,2,3,5,8])) เอาต์พุตคือ STDOUT %10และความจริงที่ว่าmapผลตอบแทนmapวัตถุในหลาม 3 เป็นบิตที่น่ารำคาญหมายถึงเราไม่สามารถทำmap(lambda*x:sum(x)%10,L,L[1:])หรือคล้ายกัน

ฟังก์ชั่นข้อผิดพลาดออก แต่แล้วก็จะเสร็จ ขอขอบคุณที่ @xsot สำหรับ -1 printไบต์โดยการหาสถานที่ที่ดีที่จะติด

05AB1E , 20 19 17 ไบต์

รหัส:

DvNð×?T%Ððý,¦‚ø€O

คำอธิบาย:

D                     # Duplicate the input.
 v                    # Map over it, running the following len(input) times.
  Nð×                 # Multiply the iteration number with a space.
     ?                # Pop and print without a newline.
      T%              # Take all integers modulo 10.
        Ð             # Triplicate the array.
         ðý,          # Join by spaces and print with a newline.
            ¦         # Remove the first element of the array.
             ‚        # Wrap it up, (pop a, b push [a, b]).
              ø       # Zip.
               €O     # Sum up each element.

ใช้การเข้ารหัสCP-1252 ลองออนไลน์! .

MATL, 32 30 29 28 27 26 25 24 ไบต์

t"X@qZ"y1X9&VhDTTH&Y+10\

บันทึก 1 ไบต์ขอบคุณ @Luis

ลองออนไลน์!

รุ่นที่แก้ไขสำหรับกรณีทดสอบทั้งหมด

คำอธิบาย

        % Implicitly grab input
t       % Duplicate the input
"       % For each element of the input (really just a shortcut to loop numel(input) times)
  X@q   % Determine the current loop index and subtract 1
  Z"    % Create an array of blanks this size (these are the padding to the left)
  y     % Copy the current array of numbers from the stack
  1X9   % Get the pre-defined output format of %.15g from the clipboard
  &V    % Convert the input to it's character representation with single spacing
  h     % Horizontally concatenate the left padding and the numbers
  D     % Display the result (consumes the string)
  TT    % Create a two-element vector of 1's ([1 1])
  H&Y+  % Convolve [1 1] with the array (computes the pair-wise sum)
  10\   % Mod 10 the result
        % Implicitly close for loop

ที่จริงแล้ว 43 ไบต์

;l;D+#"{:^%d}"%╗W;' j1╟╜f.;pXZ`i+9u@%`MdXWX

ลองออนไลน์!

โปรแกรมนี้พิมพ์บรรทัดใหม่ที่ต่อท้ายหนึ่งบรรทัดหลังเอาต์พุต

คำอธิบาย:

;l;D+#"{:^%d}"%╗W;' j1╟╜f.;pXZ`i+9u@%`MdXWX
;l;D+                                        calculate the width of the field (2L-1 where L = len(input))
     #"{:^%d}"%╗                             push to a list, make a Python new-style format string for centering text, save in reg0
                W;' j1╟╜f.;pXZ`i+9u@%`MdXW   while the top of the stack is truthy:
                 ;' j1╟                        duplicate list, join with spaces, push string to a list
                       ╜f.                     center string and print  
                          ;pXZ                 zip list with itself shifted forward by 1 (zip(a,a[1:]))
                              `i+9u@%`M        map: add each pair and mod by 10
                                       dX      discard the last value (which was not added with anything)
                                          X  discard the now-empty list after the loop to avoid printing it

Mathematica, 67 ไบต์

MatrixForm@NestList[Mod[Total/@Partition[#,2,1],10]&,#,Length@#-1]&

ตัวอย่าง:

CJam, 25 ไบต์

q~{_2ew::+Af%}h;]eeSff*N*

ลองออนไลน์!

คำอธิบาย

วิธีนี้ใช้เคล็ดลับที่ค่อนข้างเรียบร้อยเพื่อสร้างเค้าโครงสามเหลี่ยม

q~      e# Read and evaluate input.
{       e# While the list of digits is non-empty...
  _2ew  e#   Duplicate and get all sublists of length 2.
  ::+   e#   Sum each pair.
  Af%   e#   Take each result modulo 10.
}h
;]      e# Discard the final empty list and wrap the others in an array.
ee      e# Enumerate the array. E.g. for input `[7 5 0 9]` we now get this:
        e# [[0 [7 5 0 9]]
        e#  [1 [2 5 9]]
        e#  [2 [7 4]]
        e#  [3 [1]]]
Sff*    e# Perform S* on each element at depth two. For the integers from the
        e# enumeration this gives a string of that many spaces, i.e. the correct
        e# indentation. For the lists of digits this inserts a space character
        e# between every two digits, thereby spacing out the digits as necessary.
N*      e# Put linefeeds between the pairs of indentation and digit list.

JavaScript (ES6) 147 ไบต์

a=>{o=0;e=(c=>console.log(' '.repeat(o++)+c.join` `));l=1;while(l){p=0,d=[],e(a),a.map(b=>{p?d.push((v+b)%10):0;p=1,v=b});d.length<2?l=0:a=d};e(d)}

Julia, 60 59 ไบต์

\(x,s="")=x==[]?"":s*join(x," ")"
"*(diag(x'.+x,1)%10\" "s)

ขึ้นอยู่กับ@ คำตอบของ ฟังก์ชัน\รับอาร์เรย์เป็นอินพุตและส่งคืนสตริง

ลองออนไลน์!

Pyke, 21 ไบต์

lVDm}R$],FsT%)od*pKDP

ลองที่นี่!

ฉันต้องการคิดว่าวิธีนี้แตกต่างกันเล็กน้อย

[1, 2, 3, 5, 8] - take the input
[2, 4, 6, 10, 16] - double it
[1, 2, 3, 5, 8] - take the input again
[1, 1, 2, 3] - get the deltas
[[2,1], [4,1], [6,2], [10,3]] - transpose them together
[3, 5, 8, 13] - apply addition
[3, 5, 8, 3] - mod 10

Perl 6 ,  65 63 62  61 ไบต์

{put ' 'x my$++,$_ for @_,{.rotor(2=>-1).map(*.sum%10).list}...1}
{put ' 'x my$++,$_ for @_,{@(.rotor(2=>-1).map(*.sum%10))}...1}
{put ' 'x my$++,$_ for @_,{@(map *.sum%10,.rotor(2=>-1))}...1}
{put ' 'x my$++,$_ for @_,{[map *.sum%10,.rotor(2=>-1)]}...1}

คำอธิบาย:

{ # anonymous block that takes the list as input (@_)

  put # print with trailing newline

    ' ' x ( my $ )++, # pad with one more space than previous iteration
    $_                   # the list to print for this iteration
    # The ｢.Str｣ method on a List puts spaces between elements
    # which is what ｢put｣ calls on anything that isn't a Str

  for # do that for every list produced from the following

    @_, # the input list

    { # anonymous block that takes the previous list as input ($_)

      [ # turn the following from a Seq into an Array

        map
          *.sum % 10, # sum the values and modulus 10 of the following:

          # take the previous list 2 at a time, backing up one
          $_.rotor( 2 => -1 )

      ]

    }

    ... # repeatedly call that block until:

    1   # the result is only one element long
}

ตัวอย่าง:

my &digital-triangle-sum = {put ' 'x my$++,$_ for @_,{[map *.sum%10,.rotor(2=>-1)]}...1}

for [7,5,0,9], [0,1,0], [1,0,0,0], [9,2,4,5,3,2,2] -> \List {
   digital-triangle-sum List

   put '';
}

7 5 0 9
 2 5 9
  7 4
   1

0 1 0
 1 1
  2

1 0 0 0
 1 0 0
  1 0
   1

9 2 4 5 3 2 2
 1 6 9 8 5 4
  7 5 7 3 9
   2 2 0 2
    4 2 2
     6 4
      0

TSQL, 198 194 191 ไบต์

โดยใช้ GOTO แทนหนึ่งในขณะที่ฉันสามารถกอล์ฟ 3 ตัวอักษร

แข็งแรงเล่นกอล์ฟ

DECLARE @ varchar(100)= '1 2 3 4 5 6 7'

DECLARE @j INT=1,@i INT=LEN(@)a:
PRINT @
WHILE @i>@j
SELECT
@=STUFF(@,@i-1,2,RIGHT(SUBSTRING(@,@i-2,1)+SUBSTRING(@,@i,1)*1,1)+' '),@i-=2SELECT
@=STUFF(@,@j,1,' '),@j+=1,@i=LEN(@)IF @i>0GOTO a

ลองออนไลน์ (ใช้สคริปต์เก่ากับ 2 * ในขณะที่)

Java 7, 230 215 213 ไบต์

int c=0;void m(int[]a){int l=a.length,j=-1,i=-1;if(l<1)return;int[]x=new int[l-1];while(++j<c)p(" ");for(;++i<l;p(a[i]+" "))if(i<l&i>0)x[i-1]=(a[i-1]+a[i])%10;p("\n");c++;m(x);}<T>void p(T s){System.out.print(s);}

จบลงด้วยความยาวกว่าที่ฉันคิดไว้นิดหน่อย .. บางทีมันอาจจะสามารถเล่นกอล์ฟได้มากกว่านี้อีกแล้ว

บางไบต์บันทึกไว้ขอบคุณ @GiacomoGarabello

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

class Main{
  static int c = 0;

  static void m(int[] a){
    int l = a.length,
        j = -1,
        i = -1;
    if(l < 1){
      return;
    }
    int[] x = new int[l-1];
    while(++j < c){
      p(" ");
    }
    for(; ++i < l; p(a[i] + " ")){
      if(i < l & i > 0){
        x[i - 1] = (a[i - 1] + a[i]) % 10;
      }
    }
    p("\n");
    c++;
    m(x);
  }

  static <T> void p(T s){
    System.out.print(s);
  }

  static void printAndReset(int[] a){
    m(a);
    c = 0;
    System.out.println();
  }

  public static void main(String[] a){
    printAndReset(new int[]{ 7, 5, 0, 9 });
    printAndReset(new int[]{ 0 });
    printAndReset(new int[]{ 1, 2 });
    printAndReset(new int[]{ 8, 7 });
    printAndReset(new int[]{ 0, 0 });
    printAndReset(new int[]{ 1, 4, 2 });
    printAndReset(new int[]{ 0, 1, 0 });
    printAndReset(new int[]{ 1, 0, 0, 0 });
    printAndReset(new int[]{ 1, 2, 3, 4 });
    printAndReset(new int[]{ 1, 2, 3, 5, 8 });
    printAndReset(new int[]{ 9, 2, 4, 5, 3, 2, 2 });
  }
}

เอาท์พุท:

7 5 0 9 
 2 5 9 
  7 4 
   1 

0 

1 2 
 3 

8 7 
 5 

0 0 
 0 

1 4 2 
 5 6 
  1 

0 1 0 
 1 1 
  2 

1 0 0 0 
 1 0 0 
  1 0 
   1 

1 2 3 4 
 3 5 7 
  8 2 
   0 

1 2 3 5 8 
 3 5 8 3 
  8 3 1 
   1 4 
    5 

9 2 4 5 3 2 2 
 1 6 9 8 5 4 
  7 5 7 3 9 
   2 2 0 2 
    4 2 2 
     6 4 
      0 

C # 6, 125 + 31 125 + 18 = 143 ไบต์

string f(int[] n,string s="")=>s+string.Join(" ",n)+"\n"+(n.Length>1?f(n.Zip(n.Skip(1),(a,b)=>(a+b)%10).ToArray(),s+" "):"");

+18 สำหรับ using System.Linq;

ขอบคุณ @TheLethalCoder สำหรับการบันทึก 13 ไบต์โดยชี้ไปที่คำสั่งที่ไม่จำเป็นโดยใช้

JavaScript (ES6), 77 ไบต์

a=a.map((_,i)=>(b=a,a=[a.map((e,j)=>j>i?(e+a[j-1])%10:''),b.join` `)).join`
`

C, 138 ไบต์

แข็งแรงเล่นกอล์ฟ

c,d;main(int a,char**b){b++;while(c++,d=0,--a)while(d<a)printf("%*c%c",!d?c:1,*b[d],(d+2>a)*10),++d<a?*b[d-1]=(*b[d-1]+*b[d]-96)%10+48:0;}

Ungolfed

c,d;
main(int a,char**b){
b++;
while(c++,d=0,--a)
    while(d<a)
        printf("%*c%c",
          !d?c:1,      //number of blanks in front of digit
          *b[d],       //digit
          (d+2>a)*10), //returns 10(new line) only for d+1 == a
        ++d<a
          ? *b[d-1]=(*b[d-1]+*b[d]-96)%10+48 //update digit 
          :  0;
}

C #, 167 ไบต์

จริงๆแล้วฉันภูมิใจในโซลูชันนี้การแสดงออกแลมบ์ดานั้นสนุกมากเมื่อคุณได้รู้ว่า

void f(List<int> a){int x=a.Count;for(int s=0;s<x;s++){Console.WriteLine(new String(' ',s)+string.Join(" ",a));a=a.Take(x-s-1).Select((v,i)=>(a[i+1]+v)%10).ToList();}}

ungolfed ที่นี่สำหรับการปรับปรุงเพิ่มเติม:

void f(List<int> a)
{
int x = a.Count;
for (int s = 0; s<x ;s++)
{
    Console.WriteLine(new String(' ',s)+string.Join(" ",a));
    a=a.Take(x-s-1).Select((v,i)=>(a[i+1]+v)%10).ToList();
}
}

ลองที่นี่

Haskell, 139 ไบต์

f=mapM(\(r,s)->putStrLn$r++(s>>=(++" ").show)).zip(iterate(' ':)"").takeWhile(/=[]).iterate g where g(_:[])=[];g(y:p:ys)=mod(y+p)10:g(p:ys)

รับอินพุตเป็นอาร์กิวเมนต์ส่งออกไปยัง STDOUT

เวอร์ชันที่ไม่ถูกปรับแต่ง:

f = mapM (\(r, s) -> putStrLn $ r ++ (s >>= (++ " ") . show))
    . zip (iterate (' ' :) "")
    . takeWhile (/= [])
    . iterate sumTerms
    where sumTerms (_:[]) = []
          sumTerms (y:p:ys) = mod (y+p) 10 : sumTerms (p:ys)

Python 3, 97 ไบต์

def f(x):print(*x);x[-1]==''or f(['']+[(x[i]+x[i+1])%10if''!=x[i]else''for i in range(len(x)-1)])

พิมพ์บรรทัดใหม่ต่อท้ายหนึ่งบรรทัด

มันทำงานอย่างไร

def f(x):                            function with input of list of numbers
print(*x)                            print the old line of the triangle
x[-1]==''or...                       if no more numbers, stop...
(x[i]+x[i+1])%10if''!=x[i]else''...  ...else compute the next entry in the new line if
                                     possible...
...for i in range(len(x)-1)          ...for all relevant digit pairs...
['']+...                             ...concatenate with empty string to force new leading
                                     space...
f(...)                               ...and pass to function

ลองใช้กับ Ideone

J, 44 ไบต์

(#\.-#)|."_1#\.(":@{."_1)2(10|+/)\^:(]i.@#)]

ขึ้นอยู่กับการแก้ปัญหานี้

Javascript (ใช้ไลบรารีภายนอก) (198 ไบต์)

n=>{a=_.From(n);b=a.Write(" ");c=1;while(++c){a=a.BatchAccumulate(2).Where(y=>y.Count()==2).Select(z=>z.Sum()%10);if(a.Count()==0){break;}b+="\r\n"+_.Range(0,c).Write(" ",x=>"")+a.Write(" ")}return b}

ลิงก์ไปยัง lib: https://github.com/mvegh1/Enumerable/

คำอธิบายรหัส: นี่เป็นเรื่องง่ายเมื่อใช้ห้องสมุด! ไม่ชนะเป็นไบต์ แต่รหัสไม่ละเอียดเกินไปและอ่านง่าย ดังนั้นอินพุต "n 'คืออาร์เรย์ของจำนวนเต็มโหลดขึ้นในไลบรารีที่เก็บไว้ในตัวแปร" a "" b "เป็นสตริงส่งคืนเก็บสตริงที่รวมด้วย" "เป็นตัวคั่นลงใน b. c คือ การวนซ้ำปัจจุบันใช้สิ่งนี้เพื่อกำหนดจำนวนของช่องว่างที่จะแทรกหมายเหตุ: สิ่งนี้ดูเหมือนว่าจะทำงานได้ดีเมื่ออินพุตมาจาก 0-9 จากนั้นในขณะที่จริงให้ทำซ้ำชุดของรหัสที่แน่นอนรหัสนั้นคือการสร้างแบทช์ที่อยู่ติดกัน ชุดของกระแสนับ "a" คือถ้าเรามี [1,2,3,4,5,6] เราจะได้ [1,2], [2,3], [3,4], ... [ 6] ... จากนั้นจึงทำการกรองเพื่อให้เรามีขนาดที่ 2 เท่านั้นจากนั้นเราแมปกับคอลเลกชันของผลรวมของแบตช์% 10 ถ้า a ว่างเราจะทำ มิฉะนั้นเราจะเพิ่มบรรทัดใหม่ในการส่งคืนสินค้าของเรา ในที่สุดก็กลับมา ...

รูปภาพมาในไม่กี่นาที