Vâng, tổng hợp nó thực sự.

Viết chương trình hoặc hàm lấy danh sách số nguyên thập phân không trống (0-9) và đưa ra "tam giác" các chữ số hướng xuống dưới với danh sách đầu vào ở đầu, trong đó mỗi chữ số sau dòng đầu tiên là tổng của hai chữ số trên nó modulo 10.

Ví dụ: đầu vào [7, 5, 0, 9]có đầu ra

7 5 0 9
 2 5 9
  7 4
   1

vì 2là (7 + 5) mod 10, 5là (5 + 0) mod 10, 9là (0 + 9) mod 10, vv tất cả các cách để 1được (7 + 4) mod 10.

Nếu danh sách chỉ có một mục, thì đầu ra khớp với đầu vào; ví dụ như đầu vào của [4]năng suất

4

Dưới đây là một số ví dụ bổ sung:

[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

Lưu ý rằng trong đầu ra:

• Dòng đầu tiên không có không gian hàng đầu.
• Mỗi dòng tiếp theo có một không gian hàng đầu hơn dòng trước đó.
• Các chữ số được phân tách bằng một khoảng trắng.
• Mỗi dòng được phép có tối đa một khoảng trống.
• Có thể có một dòng mới tùy chọn duy nhất.
• Bạn phải sử dụng các ký tự cho các chữ số thập phân bình thường (0 đến 9).

Mã ngắn nhất tính bằng byte thắng. Tiebreaker là câu trả lời trước đó.

BrainF ** k, 396 391 byte

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

Tôi không thể cưỡng lại sự cám dỗ để làm điều này. Ít nhất là tam giác là mặt nhọn xuống.

Đầu vào xuất hiện dưới dạng một chuỗi các ký tự số theo sau là một dòng mới.

Đầu ra sẽ chứa một khoảng trống duy nhất trên mỗi dòng.

Ví dụ:

$ 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 

Giải trình

Vì khá khó để giải thích mã từ góc độ chức năng, thay vào đó chúng ta có thể xem xét nó từ góc độ trạng thái của băng ở nhiều thời điểm khác nhau. Ý tưởng cốt lõi ở đây là hình tam giác mà chúng ta tạo ra được khởi tạo dưới dạng một mảng được đóng gói chặt chẽ (đối với BF, dù sao), thu nhỏ kích thước 1 mỗi lần lặp của một vòng lặp. Một suy nghĩ quan trọng khác là chúng tôi sử dụng 255để chỉ ra một "trình giữ chỗ" mà chúng tôi có thể tìm kiếm trên băng.

Khởi tạo

Đây là bước dễ nhất. Khi bắt đầu chương trình, chúng tôi thực hiện như sau:

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

Điều này buộc băng vào trạng thái sau (trong đó >N<chỉ ra vị trí của con trỏ trên băng)

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

Số đầu tiên ở đây là một vị trí "đệm". Chúng tôi sẽ không sử dụng nó trên cơ sở lâu dài, nhưng nó hữu ích để làm cho các thao tác nhỏ đơn giản hơn và để sao chép dữ liệu xung quanh.
Số thứ hai là số khoảng trắng mà chúng ta sẽ xuất ra ở đầu mỗi dòng, bắt đầu sau dòng đầu tiên. Dòng đầu tiên sẽ không có không gian hàng đầu.
Số thứ ba là ký tự không gian chúng ta xuất ra.
Số thứ tư là một trình giữ chỗ 255, để chúng ta có thể quay lại vị trí này tương đối dễ dàng.

Đầu vào

Từ vị trí này, chúng tôi sẽ đọc trong tất cả các nhân vật. Ở cuối bước này, chúng tôi hy vọng sẽ ở trong tình huống sau:

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

Trong đó a b c d e f ...chỉ ra chuỗi các ký tự số đã được nhập (không phải dòng mới).

Chúng tôi thực hiện điều này với những điều sau đây:

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

Có một số sắc thái cho điều này. Trước hết, chúng tôi sẽ xuất ra mỗi ký tự khi chúng tôi nhận được chúng, và sau đó xuất ra một khoảng trắng sau nó. Thứ hai, chúng tôi không muốn sao chép giá trị ASCII vào băng, chúng tôi muốn sao chép chữ số thực tế. Thứ ba, chúng tôi muốn dừng lại khi chúng tôi đạt được một dòng mới và để mình ở một nơi tốt vào thời điểm đó.
Nói đầu vào của chúng tôi là 6723. Sau đó, khi đọc phần đầu tiên 6, băng của chúng tôi trông như thế này:

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

Chúng tôi kiểm tra xem giá trị này không bằng 10(một dòng mới ASCII) với ,----------[++++++++++. Sau đó, chúng tôi in ra giá trị và tiếp tục bằng cách trừ đồng thời 48 từ giá trị đầu vào và thêm 32 vào giá trị bên cạnh nó ( >>++++++++[-<++++<------>>]<), để lại cho chúng tôi ở đây:

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

Lưu ý rằng trong suốt quá trình này, chúng ta có thể giả sử rằng tất cả các chữ số ở bên phải đầu vào của chúng ta là 0 - điều này có nghĩa là chúng ta không có nguy cơ làm hỏng bất kỳ trạng thái nào trước đó nếu chúng ta sử dụng các giá trị ở bên phải để tính toán 6 * 8và 4 * 8.
Bây giờ chúng ta xuất ký tự khoảng trắng mà chúng ta vừa tạo và nhập một đầu vào mới, xóa khoảng trống chúng ta đã tính ở đó. Cuối cùng, đầu vào sẽ bị chấm dứt bởi một dòng mới và vòng lặp sẽ thoát ra, để lại một 255dòng mới sẽ là ( ,----------]-). Đây là nhân vật giữ chỗ thứ hai chúng tôi sẽ sử dụng để điều hướng băng. Tại thời điểm này trong kịch bản của chúng tôi, băng của chúng tôi chính xác là thế này:

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

Phép tính

Cách thức hoạt động này là danh sách các chữ số giữa các 255trình giữ chỗ của chúng tôi sẽ bị thu hẹp bởi mỗi lần lặp của vòng lặp. Khi nó chỉ còn lại 1 chữ số, chúng tôi đã hoàn thành và tạm dừng ngay lập tức (Lưu ý rằng, tại thời điểm này, mọi chữ số trong danh sách đó đã được xuất ra, vì vậy chúng tôi không phải lo lắng về việc xuất lại lần nữa).

Bây giờ chúng tôi sử dụng thủ thuật này để điều hướng đến 255trình giữ chỗ đầu tiên : <+[-<+]-. Điều này có hiệu quả tìm kiếm băng bên trái cho a 255, không thay đổi gì ở giữa. Bây giờ chúng ta đã di chuyển con trỏ, chúng ta có thể kiểm tra điều kiện thoát của chúng ta: nếu chỉ có một chữ số trong danh sách, thì ô hai ô bên phải sẽ giữ 255. Vì vậy, chúng tôi kiểm tra chống lại điều đó và bắt đầu một vòng lặp:>>+[-<<

Bước đầu tiên trong vòng lặp của chúng tôi là xuất ra một dòng mới. Vì vậy, chúng tôi di chuyển đến ô đầu tiên (ô đệm của chúng tôi), thêm 10 vào ô đó và xuất ra. Bước tiếp theo là xuất tất cả các ký tự không gian hàng đầu. Sau khi xuất chúng, chúng tôi tăng số lượng không gian hàng đầu. Các bước này được thực hiện bằng cách sau:

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

Điều này khiến chúng ta trong trạng thái này:

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

Bước tiếp theo của chúng tôi là sao chép giá trị đầu tiên trong danh sách, qua chỗ giữ chỗ thứ hai 255:

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

Về cơ bản, chúng tôi thực hiện điều này bằng cách nhảy qua lại giữa các trình giữ chỗ 255, để chúng tôi ở đây:

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

Bây giờ chúng tôi bắt đầu một vòng lặp, lặp qua phần còn lại của danh sách, dừng lại khi chúng tôi nhấn 255:>+[-<

Tại thời điểm này, chữ số ở bên trái của chúng tôi luôn là 0. Vì vậy, vì chúng tôi yêu thích chúng, chúng tôi đưa một người giữ chỗ 255ở đó để chúng tôi có thể quay lại vị trí của mình trong danh sách. Bước tiếp theo là di chuyển vị trí thứ hai trong danh sách đến các vị trí xung quanh nơi chúng tôi đã di chuyển vị trí đầu tiên đến, qua vị trí thứ hai 255. Các bước này được thực hiện bằng cách sau:

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

Để chúng tôi ở đây: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Bây giờ, cả 6và 7đã được chuyển đến một vị trí nơi tính toán có thể xảy ra. Chúng tôi cần hai bản sao 7vì số tiếp theo trong danh sách cũng sẽ cần nó. Các 7ngay sau khi 255phục vụ mục đích này, trong khi người kia 7sẽ được tiêu thụ bởi các tính toán.

Đầu tiên, chúng tôi thêm hai chữ số:

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

Để chúng tôi ở đây:

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

Sự kết hợp các bước tiếp theo là phức tạp nhất. Chúng ta cần xem con số chúng ta chỉ đến có lớn hơn 10 hay không và nếu có, chúng ta sẽ trừ đi 10. Trong thực tế, những gì chúng ta làm là chúng ta trừ 10 từ nó và xem liệu nó có chạm 0vào bất kỳ điểm nào trong phép trừ hay không. Nếu có, chúng tôi thêm 10lại sau. Khi kết thúc điều này, chúng ta nên có tổng modulo 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

Tại thời điểm này, chúng tôi đã hoàn thành mục tiêu. Chúng ta có tổng modulo 10! Ngoài ra, cho dù số đó có lớn hơn 10 hay không, chúng tôi sẽ kết thúc tại đây:

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

Mục tiêu tiếp theo của chúng tôi là đưa ra số tiền mới này, theo dõi nó với một khoảng trắng và đưa nó trở lại danh sách của chúng tôi. Chúng tôi làm tất cả điều này với các kỹ thuật trước đây của chúng tôi về việc 255mua sắm và thêm 48vào tổng của chúng tôi, vì vậy tôi sẽ không đề cập chi tiết.

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

Và chúng tôi ở đây: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] Lưu ý cách chúng tôi đặt một 255trình giữ chỗ bổ sung sau khi chúng tôi mới được tiêm 3để chúng tôi không bị mất vị trí trong danh sách. Tại thời điểm này, chúng ta đã xuất tổng của chúng ta và không gian của nó, vì vậy chúng ta cần dọn sạch và trở lại trạng thái nơi lần lặp tiếp theo của vòng lặp này sẽ hoạt động. Chúng ta cần hiểu rõ ràng của chúng tôi 51và 32các tế bào, di chuyển 7một lần để bên phải, và điều hướng đến danh sách giữ chỗ của chúng tôi để chúng tôi có thể bắt đầu lại.

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

Bây giờ, chúng ta đang ở đây: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
Đó chính xác là nơi chúng ta muốn trở thành lần lặp tiếp theo. Vì vậy, kiểm tra 255 và di chuyển trên! ( >+])

Khi chúng tôi bị loại khỏi vòng lặp, chúng tôi sẽ có một danh sách hoàn toàn mới - bao gồm các khoản tiền từ danh sách trước đó. Lần đầu tiên, nó sẽ trông như thế này:

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

Bây giờ chúng tôi muốn lặp lại toàn bộ quá trình đó trong danh sách mới của chúng tôi, vì vậy chúng tôi ngồi phịch 255xuống bên trái và bắt đầu lại tất cả! Chúng tôi cần phải dọn dẹp một chút >>[-]<<và sau đó bỏ giữ chỗ của chúng tôi với <-. Sau đó, chúng tôi ở cùng một nơi với chúng tôi sau khi nhập liệu, vì vậy chúng tôi có thể thoát khỏi việc thực hiện các kiểm tra tương tự: <+[-<+]->>+và bùng nổ! Chúng tôi đã có vòng lặp đầy đủ của chúng tôi! Tất cả những gì chúng ta cần là khung đóng cửa và khi nó kết thúc, chúng ta đã xuất tất cả mọi thứ, vậy là xong : ].

Thạch , 20 19 18 byte

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

Hãy thử trực tuyến!

Lý lịch

Tạo các số là đơn giản trong Jelly. Đầu ra phức tạp hơn một chút.

Jelly có một nguyên tử lưới tích hợp ( G) hiển thị danh sách 2D với các dòng mới giữa các hàng và khoảng trắng giữa các cột. Chúng tôi lấy mảng 2D của các số (được tạo với mỗi hàng được đảo ngược) và hoán chuyển nó với giá trị điền @. Sau khi hoàn nguyên mảng kết quả và hoán vị lại, áp dụng Gnăng suất như sau.

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ó được hình dạng tam giác mong muốn, tất cả những gì chúng ta phải làm là loại bỏ giá trị điền.

Làm thế nào nó hoạt động

Ṛ+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 byte

j.e+*dkjdbP.ueM+Vt

Phòng thử nghiệm .

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]

Con trăn 3.5, 74 72 71 byte

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

Đầu vào là danh sách các số nguyên (ví dụ f([1,2,3,5,8])), đầu ra là STDOUT. Và %10thực tế làmap lợi nhuận một mapđối tượng trong Python 3 là một chút khó chịu, có nghĩa là chúng ta không thể làm map(lambda*x:sum(x)%10,L,L[1:])hoặc tương đương.

Các lỗi chức năng ra, nhưng sau đó đầu ra sẽ hoàn thành. Cảm ơn @xsot cho -1 byte bằng cách tìm một vị trí tốt để dán print.

05AB1E , 20 19 17 byte

Mã số:

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

Giải trình:

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.

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! .

MATL, 32 30 29 28 27 26 25 24 byte

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

1 byte được lưu nhờ vào @Luis

Hãy thử trực tuyến!

Phiên bản sửa đổi cho tất cả các trường hợp thử nghiệm

Giải trình

        % 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

Trên thực tế, 43 byte

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

Hãy thử trực tuyến!

Chương trình này in một dòng mới duy nhất sau đầu ra.

Giải trình:

;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

Toán học, 67 byte

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

Thí dụ:

CJam, 25 byte

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

Hãy thử trực tuyến!

Giải trình

Điều này sử dụng một mẹo khá gọn gàng để tạo bố cục tam giác.

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 byte

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 byte

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

Dựa trên câu trả lời của @ Sp3000 . Hàm \chấp nhận một mảng làm đầu vào và trả về một chuỗi.

Hãy thử trực tuyến!

Pyke, 21 byte

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

Hãy thử nó ở đây!

Tôi muốn nghĩ rằng phương pháp này hơi khác một chút.

[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 byte

{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}

Giải trình:

{ # 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
}

Thí dụ:

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 byte

Bằng cách sử dụng GOTO thay vì một trong WHILE, tôi có thể chơi gôn 3 ký tự

Chơi gôn

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

Dùng thử trực tuyến (sử dụng tập lệnh cũ với 2 * WHILE)

Java 7, 230 215 213 byte

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);}

Điều này cuối cùng đã kéo dài hơn một chút so với tôi nghĩ .. Có lẽ nó có thể được đánh gôn nhiều hơn một chút, vì tôi nghĩ rằng tôi đã rối tung lên ..

Một số byte được lưu nhờ @GiacomoGarabello .

Mã thử nghiệm & mã hóa:

Hãy thử nó ở đây.

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 });
  }
}

Đầu ra:

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 byte

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 là dành cho using System.Linq;

Cảm ơn @TheLethalCoder đã lưu 13 byte, bằng cách chỉ ra một câu lệnh sử dụng không cần thiết

JavaScript (ES6), 77 byte

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

C, 138 byte

Chơi gôn

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;}

Bị đánh cắp

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 byte

Tôi thực sự khá tự hào về giải pháp này, các biểu thức lambda rất thú vị khi bạn nắm bắt được chúng

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();}}

ở đây không được cải tiến để cải thiện hơn nữa:

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();
}
}

thử nó ở đây

Haskell, 139 byte

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)

Lấy đầu vào làm đối số, xuất ra STDOUT.

Phiên bản bị đánh cắp:

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 byte

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)])

In một dòng mới duy nhất.

Làm thế nào nó hoạt động

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

Hãy thử nó trên Ideone

J, 44 byte

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

Dựa trên giải pháp này .

Javascript (sử dụng thư viện bên ngoài) (198 byte)

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}

Liên kết đến lib: https://github.com/mvegh1/Enumerable/

Giải thích mã: Điều này thật dễ dàng khi sử dụng thư viện! Không giành được byte, nhưng mã không quá dài dòng và dễ đọc. Vì vậy, đầu vào "n 'là một mảng các số nguyên. Tải nó vào thư viện, được lưu trữ trong biến" a "." B "là chuỗi trả về, lưu trữ chuỗi đã nối với" "làm dấu phân cách vào b. C là Lặp lại hiện tại, sử dụng điều này để xác định số lượng khoảng trắng cần chèn. LƯU Ý: Điều này dường như chỉ hoạt động tốt khi đầu vào từ 0-9. Sau đó, trong khi đúng, lặp lại một bộ mã nhất định. Mã đó là để tạo lô liền kề các bộ "a" hiện tại, tức là nếu chúng ta có [1,2,3,4,5,6], chúng ta sẽ nhận được [1,2], [2,3], [3,4], ... [ 6] ... sau đó lọc để chúng tôi chỉ có các lô có kích thước 2. Sau đó, chúng tôi ánh xạ tới một tập hợp các tổng số% 10. Nếu a trống, chúng tôi đã hoàn tất, khác chúng tôi thêm dòng mới để trở lại của chúng tôi. Cuối cùng cũng trở về ...

Hình ảnh đến trong một vài phút.