Peki, gerçekten topla.

Boşluksuz bir tamsayılar listesi (0-9) alan ve ilk satırdan sonraki her basamağın iki basamağın toplamı olduğu üste giriş listesi olan basamakların aşağı doğru bir "üçgenini" gösteren bir program veya işlev yazın bunun üstünde modulo 10.

Örneğin, giriş [7, 5, 0, 9]çıkışa sahiptir.

7 5 0 9
 2 5 9
  7 4
   1

Çünkü 2ise (7 + 5) mod 10, 5olduğu (5 + 0) mod 10, 9olduğunu (0 + 9) mod 10, vb için tüm yol 1olmak (7 + 4) mod 10.

Listede yalnızca bir öğe varsa, çıktı girişle eşleşir; örneğin, bir [4]verim üretecek

4

İşte bazı ek örnekler:

[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

Çıktıda şunu unutmayın:

• İlk satırın başlarında boşluk yok.
• Takip eden her satır, önceki satırdan bir öncekinden daha fazla alana sahip
• Rakamlar tek bir boşlukla ayrılır.
• Her satırın en fazla bir sondaki boşluğa sahip olmasına izin verilir.
• Tek bir isteğe bağlı izleyen yeni satır olabilir.
• Karakterleri normal ondalık basamaklar için kullanmalısınız (0 - 9 arası).

Bayt cinsinden en kısa kod kazanır. Tiebreaker daha erken bir cevaptı.

BrainF ** k, 396 391 bayt

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

Bunu yapma isteğine karşı koyamadım. En azından üçgen sivri tarafı aşağı.

Girdi, sayısal bir karakter dizisi olarak gelir ve bunu tek bir satırsonu izler.

Çıktı, her satırda tek bir boşluk bırakacaktır.

Örnekler:

$ 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 

açıklama

Kodu işlevsel bir perspektiften açıklamak oldukça zor olduğu için, bunun yerine çeşitli zamanlarda bantın durumu açısından bakabiliriz. Buradaki ana fikir, çıktığımız üçgenin, bir döngünün her yinelemesinde 1 ile küçülen, sıkıca paketlenmiş (BF için, yine de) bir dizi olarak başlatılmış olmasıdır. Bir diğer önemli düşünce, 255kasette arayabileceğimiz bir "yer tutucu" olduğunu belirtmek için kullandığımızdır .

Başlatma

Bu en kolay adım. Programın başında, aşağıdakileri yürütürüz:

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

Bu, bandı aşağıdaki duruma zorlar (burada >N<, işaretçinin banttaki konumunu gösterir)

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

Buradaki ilk sayı bir "tampon" konumdur. Uzun vadeli kullanmayacağız, ancak küçük işlemleri basitleştirmek ve verileri kopyalamak için kullanışlıdır.
İkinci sayı, her satırın başında , ilk satırdan sonra başlayacağımız boşluk sayısıdır . İlk satırın başlarında boşluk kalmayacak.
Üçüncü sayı, çıkardığımız boşluk karakteridir.
Dördüncü sayı 255'teki bir yer tutucudur, böylece bu pozisyona nispeten kolayca geri dönebiliriz.

Giriş

Bu pozisyondan itibaren tüm karakterleri okuyacağız. Bu adımın sonunda aşağıdaki durumda olmayı umuyoruz:

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

Nerede a b c d e f ...giriş oldu sayısal karakter dizesini (değil satır) gösterir.

Bunu aşağıdakilerle başardık:

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

Bunun için bazı nüanslar var. Her şeyden önce, her bir karakteri onları aldıkça çıkartacağız ve daha sonra bir boşluk çıkartacağız. İkincisi, ASCII değerini teybe kopyalamak istemiyoruz, gerçek sayısal basamağı kopyalamak istiyoruz. Üçüncüsü, yeni bir hatta çarptığımızda durup, o zaman kendimizi iyi bir yerde bırakmak istiyoruz.
Diyelim ki girişimiz 6723. Sonra, ilkini okuduktan sonra 6kasetimiz şöyle görünür:

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

Bu değerin 10(bir ASCII newline) ile eşit olmadığını kontrol ederiz ,----------[++++++++++. Ardından değeri yazdırır ve eşzamanlı olarak 48'i giriş değerinden çıkartarak ve yanındaki değere 32 ekleyerek devam ederiz ( >>++++++++[-<++++<------>>]<), bizi burada bırakır:

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

Bu süreç boyunca girdilerimizin sağındaki tüm rakamların 0 olduğunu kabul edebileceğimize dikkat edin - bu, hesaplama hakkını kullanırsak 6 * 8ve önceki herhangi bir durumu mahvetme tehlikesi altında olmadığımız anlamına gelir ve 4 * 8.
Şimdi yeni oluşturduğumuz boşluk karakterini çıkarıyoruz ve orada hesapladığımız alanı silerek yeni bir girdi alıyoruz. Sonunda giriş yeni bir satırla sonlandırılır ve yeni satırın 255bulunduğu bir nokta bırakarak döngü çıkar ,----------]-. Bu, kasette gezinmek için kullanacağımız ikinci yer tutucu karakterdir. Senaryomuzun bu noktasında kasetimiz tam olarak şudur:

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

Hesaplama

Bunun işleyiş şekli, 255yer tutucularımız arasındaki rakamların listesinin her döngüde bir kez küçüleceğidir. İçinde yalnızca 1 basamak kaldıysa, bittik ve derhal durmalıyız (Bu noktada, bu listedeki her basamağın zaten çıktı olduğunu, bu nedenle tekrar basmak için endişelenmek zorunda kalmayacağımıza dikkat edin).

Biz şimdi ilk gitmek için bu hile kullanmak 255yer tutucu: <+[-<+]-. Bu etkin bir şekilde soldaki bandı arar ve 255aradaki hiçbir şeyi değiştirmez. İşaretçiyi hareket ettirdiğimize göre, çıkış koşulumuzu kontrol edebiliriz: listede sadece bir rakam varsa, sağdaki hücre iki boşluk tutacaktır 255. Böylece, bunu kontrol edip bir döngü başlatırız:>>+[-<<

Döngüdeki ilk adım, yeni bir satır çıktısı almaktır. Böylece ilk hücreye geçiyoruz (tampon hücremiz), ona 10 ekleyip çıktısını alıyoruz. Bir sonraki adım, tüm baştaki boşluk karakterlerinin çıktısını almaktır. Bunları çıkardıktan sonra, öncü alanların sayısı için sayımızı artırırız. Bu adımlar aşağıdakilerle gerçekleştirilir:

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

Bizi bu durumda bırakan:

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

Bir sonraki adımımız, ikinci yer tutucuyu geçtikten sonra listedeki ilk değeri kopyalamaktır 255:

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

Bunu esasen yer tutucularımız arasında ileri geri 255zıplayarak bizi burada bırakarak yapıyoruz :

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

Şimdi listenin geri kalanını yineleyerek, vurduğumuzda durduran bir döngü başlatıyoruz 255:>+[-<

Bu noktada, hemen solumuzdaki hane her zaman 0'dır. Yani, onları sevdiğimiz için, 255oradaki bir yer tutucuyu açıyoruz , böylece listedeki yerimize dönebiliyoruz. Bir sonraki adım, listedeki ikinci sırayı ikinci sırayı geçen ilk sırayı taşıdığımız yerlere taşımaktır 255. Bu adımlar aşağıdakilerle gerçekleştirilir:

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

Bizi burada bırakmak: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Şimdi, hem 6ve 7hesaplama oluşabilir bir konuma taşınmıştır. İki kopyaya ihtiyacımız var, 7çünkü listedeki bir sonraki sayının da ihtiyacı olacak. Hizmetten 7hemen sonra 255bu amaca hizmet ederken, diğeri 7hesaplama tarafından tüketilecektir.

İlk önce, iki basamağı ekleriz:

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

Bizi burada bırakarak:

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

Bir sonraki adım kombinasyonu en karmaşık olanıdır. İşaret ettiğimiz sayının 10'dan büyük olup olmadığını görmemiz gerekir, öyleyse çıkarırız 10. Gerçekte yaptığımız şey, ondan 10 çıkarmamız ve çıkarmanın 0herhangi bir noktasına çarpıp çarpmadığına bakmaktır. Olursa 10, sonra ekleriz . Bunun sonunda, modulo 10 toplamına sahip olmalıyız.

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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

Bu noktada hedefi başardık. Modulo 10 toplamı bizde! Ayrıca, sayının 10'dan büyük olup olmaması da burada sona erer:

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

Bir sonraki hedefimiz bu yeni toplamı çıkarmak, bir boşlukla takip etmek ve tekrar listemize enjekte etmek. Bunları daha önce 255atlama-toplama ve toplamımıza ekleme tekniklerimizle yapıyoruz 48, bu yüzden onu ayrıntılı olarak anlatmayacağım .

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

Ve biz buradayız: Yeni enjekte edildikten sonra [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] ek bir 255yer tutucuyu nasıl yerleştirdiğimize dikkat edin, 3böylece listede yerimizi kaybetmeyelim. Bu noktada, toplamımızı ve alanını çıkardık, bu yüzden bu döngünün bir sonraki yinelemesinin işe yarayacağı bir duruma temizlememiz ve geri dönmemiz gerekir. Hücrelerimizi temizlememiz , bir kez sağa doğru hareket etmemiz 51ve başlayabilmemiz için liste yer tutucuya gitmemiz gerekir.327

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

Şimdi, biz buradayız: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
Bu tam olarak bir sonraki yinelememiz için olmak istediğimiz yer. Yani 255'i kontrol et ve devam et! ( >+])

Döngüden ayrıldığımızda, önceki listenin toplamından oluşan yepyeni bir listeye sahip olacağız. İlk defa, şuna benzer:

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

Şimdi tüm bu işlemi yeni listemizde tekrarlamak istiyoruz, bu yüzden 255sola doğru aşağıya atlayıp baştan başlıyoruz! Ile biraz temizlik yapmamız >>[-]<<ve sonra da yer tutucumuzu düşürmemiz gerekiyor <-. Ondan sonra, biz girdikten sonra tam olarak aynı yerdeyiz, bu yüzden aynı kontrolleri yaparak kurtulabiliriz:, <+[-<+]->>+ve patlama! Tam döngümüzü aldık! Elimizde ihtiyaç kapanış ayracı olduğunu ve sona erdiğinde bitti yüzden, zaten çıkış herşeyi ettik: ].

Jöle , 20 19 18 bayt

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

Çevrimiçi deneyin!

Arka fon

Jelly'de sayıları oluşturmak basittir. Çıktı biraz daha karmaşık.

Jelly, Gsatırlar ve sütunlar arasındaki boşluklar arasında yeni satırlara sahip bir 2B liste görüntüleyen yerleşik bir ızgara atomuna ( ) sahiptir. 2B sayı dizisini alırız (her satır tersten üretilir) ve onu doldurma değeriyle değiştiririz @. Elde edilen diziyi geri alıp tekrar transpoze ettikten sonra G, aşağıdaki sonucu elde edilir.

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

İstenilen üçgen şekli elde etmek için tek yapmamız gereken doldurma değerini kaldırmaktır.

Nasıl çalışır

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

j.e+*dkjdbP.ueM+Vt

Test Takı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]

Python 3.5, 74 72 71 bayt

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

Giriş bir tamsayı listesidir (örn. f([1,2,3,5,8])), Çıkış STDOUT'a yapılır. %10Ve aslında mapbir getiri mapPython 3 nesne yapamayacağımız anlamına biraz can sıkıcı map(lambda*x:sum(x)%10,L,L[1:])ya da benzer.

İşlev hata verir, ancak o zamana kadar çıktı tamamlanmış olur. Yapıştırmak için iyi bir yer bularak -1 byte için @ xsot sayesinde print.

05AB1E , 20 19 17 bayt

Kod:

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

Açıklama:

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 kodlamasını kullanır . Çevrimiçi deneyin! .

MATL, 32 30 29 28 27 26 25 24 bayt

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

@Luis sayesinde 1 Bayt kaydedildi

Çevrimiçi Deneyin!

Tüm test durumları için değiştirilmiş versiyon

açıklama

        % 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

Aslında, 43 bayt

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

Çevrimiçi deneyin!

Bu program çıktıdan sonra tek bir izleyen yeni satır yazdırır.

Açıklama:

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

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

Örnek:

CJam, 25 bayt

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

Çevrimiçi deneyin!

açıklama

Bu üçgen düzeni oluşturmak için oldukça düzgün bir hile kullanır.

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 bayt

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 bayt

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

@ Sp3000'in cevabı dayanarak . İşlev \bir diziyi girdi olarak kabul eder ve bir dize döndürür.

Çevrimiçi deneyin!

Pyke, 21 bayt

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

Burada dene!

Bu yöntemin biraz farklı olduğunu düşünmek istiyorum.

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

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

Açıklama:

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

Örnek:

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 bayt

WHILE’nin yerine GOTO’yu kullanarak 3 karakter golf oynadım

golfed

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

Çevrimiçi deneyin (2 * WHILE ile eski komut dosyasını kullanarak)

Java 7, 230 215 213 bayt

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

Bu düşündüğümden biraz daha uzun sürdü ... Belki biraz daha golf oynayabilir, çünkü biraz karışıklığa uğradım sanırım ..

@GiacomoGarabello sayesinde bazı baytlar kaydedildi .

Ungolfed ve test kodu:

Burada dene.

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

Çıktı:

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 bayt

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;

Gereksiz bir kullanım ifadesi işaret ederek 13 byte tasarruf için @ TheLethalCoder sayesinde

JavaScript (ES6), 77 bayt

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

C, 138 bayt

golfed

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 bayt

Aslında bu çözümden oldukça gurur duyuyorum, lambda ifadeleri bir kez asıldıklarında çok eğlenceli

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

burada daha fazla iyileştirme için unungolfed:

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

burada dene

Haskell, 139 bayt

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)

Girdiyi argüman olarak alır, STDOUT'a çıkar.

Ungolfed versiyonu:

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 bayt

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

Tek bir izleyen yeni satır yazdırır.

Nasıl çalışır

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'da dene

J, 44 bayt

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

Bu çözüme dayanarak .

Javascript (harici kütüphaneyi kullanarak) (198 bayt)

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 bağlantısı: https://github.com/mvegh1/Enumerable/

Kod açıklaması: Bu kitaplığı kullanmak kolaydı! Bayt cinsinden kazanmaz, ancak kod çok ayrıntılı ve okunması kolay değildir. Bu nedenle, "n" girişi bir tamsayı dizisidir. "A" değişkeninde saklanan kitaplığa yükleyin, b "dönüş dizisi, b" 'deki sınırlayıcı olarak b " geçerli yineleme, eklemek için boşluk sayısını belirlemek için bunu kullanın .. NOT: Bu, yalnızca giriş 0-9 arasındayken güzel çalışıyor gibi görünüyor.Daha sonra, doğruyken, belirli bir kod kümesini tekrarlayın. mevcut "a" sayılabilir kümelerini, yani [1,2,3,4,5,6] alıyorsak, [1,2], [2,3], [3,4], ... [ 6] ... sonra filtreleyin, böylece sadece 2 büyüklükteki partilere sahibiz. Sonra bunu% 10'luk partilerin toplamı koleksiyonuna eşleriz. A boşsa, bitti, yoksa yeni satırı iadeimize ekliyoruz. Sonunda dönüş ...

Resim birkaç dakika içinde geliyor.