Ну, підсумуйте справді.

Напишіть програму або функцію, яка містить непорожній список десяткових цілих чисел (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).

Виграє найкоротший код у байтах. Тирбейкер - це відповідь раніше.

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

Перше число тут - "буфер". Ми не збираємось використовувати його довгостроково, але корисно зробити невеликі операції простішими та копіювати дані навколо.
Друге число - це кількість пробілів, які ми будемо виводити на початку кожного рядка, починаючи після першого рядка. У першому рядку не буде провідних пробілів.
Третє число - пробільний символ, який ми виводимо.
Четверте число - це заповнення 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.
Тепер ми виводимо символ простору, який ми щойно створили, і вводимо новий ввід, видаляючи прорахований нами простір. Врешті-решт, вхід буде припинено новим рядком, і цикл вийде, залишаючи a, 255де був би новий рядок ( ,----------]-). Це другий символ заповнювача, який ми будемо використовувати для навігації по стрічці. На даний момент у нашому сценарії наша стрічка саме така:

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

Розрахунок

Як це працює, це те, що список цифр між нашими 255заповнювачами зменшиться по одній ітерації циклу. Коли в ньому залишилося лише одна цифра, ми закінчили і повинні негайно зупинитися (зауважте, що в цей момент кожна цифра у цьому списку вже виведена, тому нам не доведеться турбуватися про її виведення знову).

Тепер ми використовуємо цей трюк , щоб перейти до першого 255заповнювач: <+[-<+]-. Це ефективно шукає стрічку ліворуч 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 просто. Вихід трохи складніший.

У Jelly є вбудований атом сітки ( G), який відображає двовимірний список з новими рядками між рядками та пробілами між стовпцями. Беремо 2D масив чисел (згенерований з кожним рядком, перевернутим), і переносимо його зі значенням заповнення @. Після повернення отриманого масиву та перенесення знову, застосувавши, 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

Тестовий сюїт .

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об’єкт в Python 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

Математика, 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)}

Юлія, 60 59 байт

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

На основі @ відповідь Sp3000 в . Функція \приймає масив як вхідний і повертає рядок.

Спробуйте в Інтернеті!

Пайк, 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 замість одного із WHILE, я зміг переграти 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 * WHILE)

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 .

Невикористаний і тестовий код:

Спробуйте тут.

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

Безумовно

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

тут неозорений для подальших удосконалень:

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. Потім, хоча істинно, повторіть певний набір коду. Цей код повинен створити сусідню партію. множини поточного числового "а", тобто якщо у нас [1,2,3,4,5,6] отримаємо [1,2], [2,3], [3,4], ... [ 6] ... потім фільтруємо так, щоб у нас були лише партії розміром 2. Потім ми відображаємо це до колекції сум партій% 10. Якщо a порожній, ми закінчуємо, інакше ми додамо новий рядок до нашого повернення. Нарешті поверніться ...

Зображення виходить через кілька хвилин.