Ну, подведи итог.

Напишите программу или функцию, которая принимает непустой список десятичных целых чисел (0-9) и выводит «треугольник» цифр, указывающий вниз, со списком ввода вверху, где каждая цифра после первой строки является суммой двух цифр выше по модулю 10.

Например, вход [7, 5, 0, 9]имеет выход

7 5 0 9
 2 5 9
  7 4
   1

потому что 2есть (7 + 5) mod 10, 5есть (5 + 0) mod 10, 9есть (0 + 9) mod 10и т. д. весь путь к 1бытию (7 + 4) mod 10.

Если в списке есть только один элемент, то выходные данные соответствуют входным данным; например, ввод [4]даст

4

Вот несколько дополнительных примеров:

[0]

0

[1, 2]

1 2
 3

[8, 7]

8 7
 5

[0, 0]

0 0
 0

[1, 4, 2]

1 4 2
 5 6
  1

[0, 1, 0]

0 1 0
 1 1
  2

[1, 0, 0, 0]

1 0 0 0
 1 0 0
  1 0
   1

[1, 2, 3, 4]

1 2 3 4
 3 5 7
  8 2
   0

[1, 2, 3, 5, 8]

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

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

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

Обратите внимание, что в выводе:

• Первая строка не имеет начальных пробелов.
• Каждая последующая строка имеет на один пробел больше, чем предыдущая.
• Цифры разделены одним пробелом.
• Каждая строка может иметь до одного пробела.
• Там может быть один необязательный трейлинг новой строки.
• Вы должны использовать символы для нормальных десятичных цифр (от 0 до 9).

Самый короткий код в байтах побеждает. Tiebreaker - более ранний ответ.

BrainF ** k, 396 391 байт

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

Я не мог устоять перед искушением сделать это. По крайней мере, треугольник остроконечной стороной вниз.

Ввод осуществляется в виде строки числовых символов, за которой следует одна новая строка.

Выходные данные будут содержать один завершающий пробел в каждой строке.

Примеры:

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

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

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

объяснение

Поскольку объяснить код довольно сложно с функциональной точки зрения, мы можем вместо этого взглянуть на него с точки зрения состояния ленты в разное время. Основная идея заключается в том, что треугольник, который мы выводим, инициализируется как плотно упакованный (для BF, в любом случае) массив, размер которого уменьшается на 1 при каждой итерации цикла. Другая важная мысль заключается в том, что мы используем 255для обозначения «заполнителя», который мы можем искать на ленте.

инициализация

Это самый простой шаг. В начале программы мы выполняем следующее:

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

Это переводит ленту в следующее состояние (где >N<указывается расположение указателя на ленте)

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

Первый номер здесь - это «буфер». Мы не собираемся использовать его на долгосрочной основе, но это полезно для упрощения небольших операций и для копирования данных.
Второе число этого количество мест , которые мы будем Выведение в начале каждой строки, начиная после первой строки. В первой строке не будет пробелов.
Третье число - это пробел, который мы выводим.
Четвертое число - это заполнитель 255, так что мы можем относительно легко вернуться к этой позиции.

вход

С этой позиции мы будем читать все символы. В конце этого шага мы надеемся оказаться в следующей ситуации:

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

Где a b c d e f ...указывает строку числовых символов, которые были введены (не перевод строки).

Мы осуществляем это с помощью следующего:

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

В этом есть некоторые нюансы. Прежде всего, мы будем выводить каждый символ по мере его получения, а затем выводить пробел после него. Во-вторых, мы не хотим копировать значение ASCII на ленту, мы хотим скопировать действительную цифровую цифру. В-третьих, мы хотим остановиться, когда выйдем на новую строку, и оставить себя в то время в хорошем месте.
Скажите, что наш вклад 6723. Затем, после прочтения первого 6, наша лента выглядит так:

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

Мы проверяем, что это значение не равно 10(новая строка ASCII) с ,----------[++++++++++. Затем мы выводим значение и продолжаем, одновременно вычитая 48 из входного значения и добавляя 32 к значению рядом с ним ( >>++++++++[-<++++<------>>]<), оставляя нас здесь:

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

Обратите внимание, что на протяжении всего этого процесса мы можем предполагать, что все цифры справа от нашего ввода равны 0 - это означает, что мы не рискуем испортить любое предыдущее состояние, если мы будем использовать значения справа для вычисления 6 * 8и 4 * 8.
Теперь мы выводим только что сгенерированный символ пробела и вводим новый ввод, удаляя вычисленное там пространство. В конце концов, ввод будет завершен новой строкой, и цикл завершится, оставив там, 255где была бы новая строка ( ,----------]-). Это второй символ-заполнитель, который мы будем использовать для навигации по ленте. На данный момент в нашем сценарии наша лента точно такая:

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

расчет

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

Теперь мы используем этот трюк , чтобы перейти к первому 255заполнителя: <+[-<+]-. Это эффективно ищет ленту слева 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ḟ”@

Попробуйте онлайн!

Задний план

Генерация чисел в желе проста. Вывод немного сложнее.

В желе есть встроенная сетка atom ( 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тот факт, что объект Python 3 mapвозвращает mapобъект, немного раздражает, а это означает, что мы не можем сделать это map(lambda*x:sum(x)%10,L,L[1:])или подобное.

Функция выдает ошибку, но к тому времени вывод завершится. Спасибо @xsot за -1 байт, найдя хорошее место для вставки print.

05AB1E , 20 19 17 байт

Код:

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

Объяснение:

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

Использует кодировку CP-1252 . Попробуйте онлайн! ,

MATL, 32 30 29 28 27 26 25 24 байта

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

1 байт сохранен благодаря @Luis

Попробуйте онлайн!

Модифицированная версия для всех тестовых случаев

объяснение

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

На самом деле, 43 байта

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

Попробуйте онлайн!

Эта программа печатает один завершающий символ новой строки после вывода.

Объяснение:

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

Mathematica, 67 байт

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

Пример:

CJam, 25 байтов

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

Попробуйте онлайн!

объяснение

Это использует довольно аккуратный трюк для генерации макета треугольника.

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

JavaScript (ES6) 147 байт

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

Юлия, 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 персонажами

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

Попробуйте онлайн (используя старый скрипт с 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 .

Ungolfed & тестовый код:

Попробуй это здесь.

class Main{
  static int c = 0;

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

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

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

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

Выход:

7 5 0 9 
 2 5 9 
  7 4 
   1 

0 

1 2 
 3 

8 7 
 5 

0 0 
 0 

1 4 2 
 5 6 
  1 

0 1 0 
 1 1 
  2 

1 0 0 0 
 1 0 0 
  1 0 
   1 

1 2 3 4 
 3 5 7 
  8 2 
   0 

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

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

C # 6, 125 + 31, 125 + 18 = 143 байта

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

+18 для using System.Linq;

Спасибо @TheLethalCoder за сохранение 13 байт, указав на ненужный оператор использования

JavaScript (ES6), 77 байт

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

C, 138 байтов

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 байт

Я на самом деле очень горжусь этим решением, лямбда-выражения становятся такими забавными, когда вы освоите

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. Затем, при true, повторите определенный набор кода. Этот код должен создать соседний пакет наборы текущего перечисляемого «а», т.е. если у нас есть [1,2,3,4,5,6], мы получаем [1,2], [2,3], [3,4], ... [ 6] ... затем отфильтруйте, чтобы у нас были только партии размером 2. Затем мы сопоставим это с набором сумм партий% 10. Если a пусто, мы закончили, иначе мы добавим новую строку к нашему возвращению. Наконец-то вернусь ...

Изображение приходит через несколько минут.