Yah, jumlahkan itu benar-benar.

Tulis sebuah program atau fungsi yang mengambil dalam daftar kosong dari bilangan bulat desimal (0-9) dan menghasilkan "segitiga" menunjuk ke bawah digit dengan daftar input di bagian atas di mana setiap digit setelah baris pertama adalah jumlah dari dua digit di atasnya modulo 10.

Misalnya, input [7, 5, 0, 9]memiliki output

7 5 0 9
 2 5 9
  7 4
   1

karena 2adalah (7 + 5) mod 10, 5adalah (5 + 0) mod 10, 9adalah (0 + 9) mod 10, dll. semua jalan menuju 1keberadaan (7 + 4) mod 10.

Jika daftar hanya memiliki satu item, maka output cocok dengan input; misalnya input [4]kehendak menghasilkan

4

Berikut ini beberapa contoh tambahan:

[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

Perhatikan bahwa dalam output:

• Baris pertama tidak memiliki spasi di depan.
• Setiap baris berikutnya memiliki satu ruang terdepan lebih banyak dari garis sebelumnya.
• Digit dipisahkan oleh satu ruang.
• Setiap baris diizinkan memiliki hingga satu ruang tambahan.
• Mungkin ada satu trailing newline opsional.
• Anda harus menggunakan karakter untuk angka desimal normal (0 hingga 9).

Kode terpendek dalam byte menang. Tiebreaker adalah jawaban sebelumnya.

BrainF ** k, 396 391 byte

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

Saya tidak bisa menahan diri dari godaan untuk melakukan hal ini. Paling tidak segitiga itu sisi-runcing ke bawah.

Input masuk sebagai string karakter numerik diikuti oleh satu baris baru.

Output akan berisi ruang trailing tunggal di setiap baris.

Contoh:

$ 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 

Penjelasan

Karena agak sulit untuk menjelaskan kode dari perspektif fungsional, kita dapat melihatnya dari perspektif keadaan rekaman pada berbagai waktu. Gagasan inti di sini adalah bahwa segitiga yang kita hasilkan diinisialisasi sebagai array (untuk BF, bagaimanapun) yang padat yang menyusut dalam ukuran sebesar 1 setiap iterasi dari sebuah loop. Pikiran penting lainnya adalah bahwa kita menggunakan 255untuk menunjukkan "pengganti" yang dapat kita cari di rekaman itu.

Inisialisasi

Ini adalah langkah termudah. Pada awal program, kami menjalankan yang berikut:

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

Ini memaksa kaset ke dalam kondisi berikut (di mana >N<menunjukkan lokasi pointer pada tape)

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

Angka pertama di sini adalah lokasi "buffer". Kami tidak akan menggunakannya dalam jangka panjang, tetapi berguna untuk membuat operasi lebih sederhana dan untuk menyalin data.
Angka kedua adalah jumlah spasi yang akan kami hasilkan di awal setiap baris, dimulai setelah baris pertama. Baris pertama tidak akan memiliki ruang utama.
Angka ketiga adalah karakter spasi yang kita hasilkan.
Angka keempat adalah placeholder 255, sehingga kita bisa kembali ke posisi ini dengan relatif mudah.

Memasukkan

Dari posisi ini, kita akan membaca semua karakter. Pada akhir langkah ini, kami berharap berada dalam situasi berikut:

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

Di mana a b c d e f ...menunjukkan string karakter numerik yang dimasukkan (bukan baris baru).

Kami mencapai ini dengan yang berikut:

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

Ada beberapa nuansa untuk ini. Pertama-tama, kita akan menampilkan setiap karakter saat kita mendapatkannya, dan kemudian mengeluarkan spasi setelahnya. Kedua, kami tidak ingin menyalin nilai ASCII ke rekaman, kami ingin menyalin angka numerik yang sebenarnya. Ketiga, kami ingin berhenti ketika kami mencapai baris baru dan meninggalkan diri kami di tempat yang baik pada saat itu.
Katakan input kita 6723. Kemudian, setelah membaca yang pertama 6, rekaman kami terlihat seperti ini:

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

Kami memeriksa bahwa nilai ini tidak sama dengan 10(baris ASCII) dengan ,----------[++++++++++. Kami kemudian mencetak nilai dan melanjutkan dengan mengurangi secara bersamaan 48 dari nilai input dan menambahkan 32 ke nilai di sebelahnya ( >>++++++++[-<++++<------>>]<), meninggalkan kami di sini:

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

Perhatikan bahwa selama proses ini kita dapat mengasumsikan bahwa semua digit di sebelah kanan input kami adalah 0 - ini berarti bahwa kami tidak dalam bahaya merusak keadaan sebelumnya jika kami menggunakan nilai di sebelah kanan untuk menghitung 6 * 8dan 4 * 8.
Sekarang kita menampilkan karakter spasi yang baru saja kita buat, dan menerima input baru, menghapus ruang yang kita hitung di sana. Akhirnya, input akan dihentikan oleh baris baru dan loop akan keluar, meninggalkan tempat di 255mana baris baru seharusnya ( ,----------]-). Ini adalah karakter placeholder kedua yang akan kita gunakan untuk menavigasi rekaman itu. Pada titik ini dalam skenario kami, rekaman kami persis seperti ini:

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

Perhitungan

Cara kerjanya adalah daftar digit antara 255placeholder kami akan menyusut satu per iterasi dari loop. Ketika hanya memiliki 1 digit yang tersisa di dalamnya, kita sudah selesai dan harus segera berhenti (Perhatikan bahwa, pada titik ini, setiap digit dalam daftar itu sudah menjadi keluaran, jadi kita tidak perlu khawatir tentang mengeluarkannya lagi).

Kami sekarang menggunakan trik ini untuk menavigasi dengan yang pertama 255placeholder: <+[-<+]-. Ini secara efektif mencari rekaman di sebelah kiri untuk 255, tidak mengubah apa pun di antaranya. Sekarang kita telah memindahkan pointer, kita dapat memeriksa kondisi keluar kita: jika hanya ada satu digit dalam daftar, maka sel dua spasi di sebelah kanan akan tahan 255. Dengan demikian, kami memeriksa hal itu dan memulai perulangan:>>+[-<<

Langkah pertama di loop kami adalah untuk menghasilkan baris baru. Jadi kami pindah ke sel pertama (sel buffer kami), tambahkan 10 ke sana dan hasilkan. Langkah selanjutnya adalah menampilkan semua karakter ruang terkemuka. Setelah mengeluarkannya, kami menambah jumlah kami untuk sejumlah ruang utama. Langkah-langkah ini dilakukan dengan yang berikut:

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

Yang membuat kita dalam keadaan ini:

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

Langkah kami selanjutnya adalah menyalin nilai pertama dalam daftar, melewati placeholder kedua 255:

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

Kami pada dasarnya melakukan ini dengan melompat-lompat di antara placeholder kami 255, meninggalkan kami di sini:

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

Kami sekarang memulai perulangan, mengulangi seluruh daftar, berhenti ketika kami menekan 255:>+[-<

Pada titik ini, angka di sebelah kiri langsung kita selalu 0. Jadi, karena kita mencintai mereka, kita memasukkan tempat penampung 255di sana sehingga kita dapat kembali ke tempat kita dalam daftar. Langkah selanjutnya adalah memindahkan tempat kedua dalam daftar ke lokasi di sekitar tempat kami memindahkan tempat pertama, melewati tempat penampung kedua 255. Langkah-langkah ini dilakukan dengan yang berikut:

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

Meninggalkan kami di sini: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Sekarang, baik 6dan 7telah dipindahkan ke lokasi di mana perhitungan dapat terjadi. Kami memerlukan dua salinan 7karena nomor berikutnya dalam daftar akan memerlukannya juga. The 7segera setelah 255melayani tujuan ini, sedangkan yang lain 7akan dikonsumsi oleh perhitungan.

Pertama, kami menambahkan dua digit:

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

Meninggalkan kami di sini:

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

Kombinasi langkah-langkah selanjutnya adalah yang paling rumit. Kita perlu melihat apakah angka yang kita tunjuk lebih besar dari 10, dan jika ya, kita kurangi 10. Pada kenyataannya, apa yang kita lakukan adalah kita mengurangi 10 dari itu dan melihat apakah itu mencapai 0titik apa pun dalam pengurangan itu. Jika ya, kami tambahkan 10lagi nanti. Pada akhir ini, kita harus memiliki jumlah 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

Pada titik ini, kami telah mencapai tujuan. Kami memiliki jumlah modulo 10! Juga, apakah jumlahnya lebih besar dari 10, kita akan berakhir di sini:

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

Tujuan kami berikutnya adalah untuk mengeluarkan jumlah baru ini, mengikutinya dengan spasi, dan menyuntikkannya kembali ke daftar kami. Kami melakukan ini semua dengan teknik sebelumnya kami - 255melompat dan menambah 48jumlah kami, jadi saya tidak akan membahasnya secara rinci.

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

Dan kami di sini: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] Perhatikan bagaimana kami menempatkan 255placeholder tambahan setelah kami yang baru disuntikkan 3sehingga kami tidak kehilangan tempat dalam daftar. Pada titik ini, kami memiliki output jumlah dan ruangnya, jadi kami perlu membersihkan dan kembali ke keadaan di mana iterasi berikutnya dari loop ini akan berfungsi. Kita perlu membersihkan sel 51dan kita 32, memindahkan yang 7satu ke kanan, dan menavigasi ke placeholder daftar kita sehingga kita bisa memulai dari awal.

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

Sekarang, kita di sini: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
Di mana tepatnya kita ingin berada untuk iterasi berikutnya. Jadi periksa 255 dan lanjutkan! ( >+])

Ketika kita diturunkan dari loop, kita akan memiliki daftar baru - terdiri dari jumlah dari daftar sebelumnya. Pertama kali, akan terlihat seperti ini:

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

Sekarang kami ingin mengulangi seluruh proses itu di daftar baru kami, jadi kami 255turunkan ke kiri dan mulai dari awal lagi! Kita perlu melakukan sedikit pembersihan dengan >>[-]<<, dan kemudian menjatuhkan placeholder kita <-. Setelah itu, kami berada di tempat yang persis sama dengan yang kami cari, sehingga kami bisa lolos dengan melakukan pemeriksaan yang sama:, <+[-<+]->>+dan boom! Kami punya loop penuh kami! Semua yang kita butuhkan adalah penutupan braket, dan ketika itu berakhir kita sudah sudah keluaran segalanya, jadi kita sudah selesai: ].

Jelly , 20 19 18 byte

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

Cobalah online!

Latar Belakang

Menghasilkan angka langsung di Jelly. Outputnya sedikit lebih rumit.

Jelly memiliki atom kotak bawaan ( G) yang menampilkan daftar 2D dengan baris baru di antara baris dan spasi di antara kolom. Kami mengambil array angka 2D (dihasilkan dengan setiap baris dibalik), dan memindahkannya dengan nilai isian @. Setelah memuja array yang dihasilkan dan transposing lagi, menerapkan Ghasil berikut.

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

Untuk mendapatkan bentuk segitiga yang diinginkan, yang harus kita lakukan adalah menghapus nilai isian.

Bagaimana itu bekerja

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

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 byte

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

Input adalah daftar bilangan bulat (mis. f([1,2,3,5,8])), Output ke STDOUT. The %10dan fakta bahwa mappengembalian suatu mapobjek di Python 3 adalah sedikit mengganggu, berarti kita tidak bisa melakukan map(lambda*x:sum(x)%10,L,L[1:])atau serupa.

Fungsi kesalahan keluar, tetapi pada saat itu output akan selesai. Terima kasih kepada @xsot untuk -1 byte dengan menemukan tempat yang bagus untuk menempel print.

05AB1E , 20 19 17 byte

Kode:

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

Penjelasan:

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.

Menggunakan pengkodean CP-1252 . Cobalah online! .

MATL, 32 30 29 28 27 26 25 24 byte

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

1 Byte disimpan berkat @Luis

Cobalah secara Online!

Versi modifikasi untuk semua kasus uji

Penjelasan

        % 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

Sebenarnya, 43 byte

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

Cobalah online!

Program ini mencetak satu baris baru setelah output.

Penjelasan:

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

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

Contoh:

CJam, 25 byte

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

Cobalah online!

Penjelasan

Ini menggunakan trik yang cukup rapi untuk menghasilkan tata letak segitiga.

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)

Berdasarkan jawaban @ Sp3000 . Fungsi \menerima array sebagai input dan mengembalikan string.

Cobalah online!

Pyke, 21 byte

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

Coba di sini!

Saya ingin berpikir metode ini sedikit berbeda.

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

Penjelasan:

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

Contoh:

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

Dengan menggunakan GOTO alih-alih salah satu WHILE, saya bisa bermain golf 3 karakter

Golf

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

Cobalah secara online (menggunakan skrip lama dengan 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);}

Ini akhirnya menjadi sedikit lebih lama dari yang saya kira .. Mungkin bisa bermain golf sedikit lebih, karena saya agak kacau saya pikir ..

Beberapa byte disimpan berkat @GiacomoGarabello .

Tidak digabungkan & kode uji:

Coba di sini.

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

Keluaran:

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 untuk using System.Linq;

Terima kasih kepada @TheLethalCoder untuk menghemat 13 byte, dengan menunjukkan pernyataan penggunaan yang tidak perlu

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

Golf

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

Tidak disatukan

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

Sebenarnya saya cukup bangga dengan solusi ini, ekspresi lambda sangat menyenangkan setelah Anda memahami mereka

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

di sini ungolfed untuk perbaikan lebih lanjut:

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

coba di sini

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)

Mengambil input sebagai argumen, menghasilkan ke STDOUT.

Versi tidak disatukan:

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

Mencetak satu trailing newline.

Bagaimana itu bekerja

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

Cobalah di Ideone

J, 44 byte

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

Berdasarkan solusi ini .

Javascript (menggunakan perpustakaan eksternal) (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}

Tautan ke lib: https://github.com/mvegh1/Enumerable/

Penjelasan kode: Ini mudah menggunakan perpustakaan! Tidak menang dalam byte, tetapi kode ini tidak terlalu bertele-tele dan mudah dibaca. Jadi, input "n 'adalah array bilangan bulat. Muatkannya ke dalam perpustakaan, disimpan dalam variabel" a "." B "adalah string kembali, simpan string yang digabungkan dengan" "sebagai pembatas menjadi b. C adalah iterasi saat ini, gunakan ini untuk menentukan jumlah spasi untuk disisipkan CATATAN: Ini hanya berfungsi dengan baik ketika input dari 0-9.Kemudian, ketika benar, ulangi satu set kode tertentu .Kode itu adalah untuk membuat batch yang berdekatan set enumerable "a" saat ini, yaitu jika kita memiliki [1,2,3,4,5,6] kita mendapatkan [1,2], [2,3], [3,4], ... [ 6] ... lalu saring sehingga kita hanya memiliki kumpulan ukuran 2. Kemudian kita memetakannya ke kumpulan jumlah kumpulan% 10. Jika a kosong, kita selesai, kalau tidak kita tambahkan baris baru untuk pengembalian kita. Akhirnya kembali ...

Gambar datang dalam beberapa menit.