Bem, resumir realmente.

Escreva um programa ou função que inclua uma lista não vazia de números inteiros decimais (0-9) e emita um "triângulo" de dígitos apontando para baixo com a lista de entrada na parte superior, onde cada dígito após a primeira linha é a soma dos dois dígitos acima dele módulo 10.

Por exemplo, a entrada [7, 5, 0, 9]possui saída

7 5 0 9
 2 5 9
  7 4
   1

porque 2é (7 + 5) mod 10, 5é (5 + 0) mod 10, 9é (0 + 9) mod 10, etc. todo o caminho para 1ser (7 + 4) mod 10.

Se a lista tiver apenas um item, a saída corresponderá à entrada; por exemplo, uma entrada de [4]produzirá

4

Aqui estão alguns exemplos adicionais:

[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

Observe que na saída:

• A primeira linha não possui espaços à esquerda.
• Cada linha subseqüente possui mais um espaço inicial que a linha anterior.
• Os dígitos são separados por um único espaço.
• Cada linha pode ter até um espaço à direita.
• Pode haver uma única nova linha opcional à direita.
• Você deve usar os caracteres para dígitos decimais normais (0 a 9).

O código mais curto em bytes vence. O desempatador é a resposta anterior.

BrainF ** k, 396 391 bytes

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

Eu não pude resistir à tentação de fazer este. Pelo menos o triângulo está do lado pontudo para baixo.

A entrada é inserida como uma sequência de caracteres numéricos seguida por uma única nova linha.

A saída conterá um único espaço à direita em cada linha.

Exemplos:

$ 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 

Explicação

Como é bastante difícil explicar o código de uma perspectiva funcional, podemos analisá-lo da perspectiva do estado da fita em vários momentos. A idéia central aqui é que o triângulo que produzimos seja inicializado como uma matriz compactada (para BF, enfim) que diminua de tamanho em 1 a cada iteração de um loop. Outro pensamento importante é que usamos 255para indicar um "espaço reservado" que podemos procurar na fita.

Inicialização

Este é o passo mais fácil. No início do programa, executamos o seguinte:

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

Isso força a fita no seguinte estado (onde >N<indica o local do ponteiro na fita)

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

O primeiro número aqui é um local "buffer". Não vamos usá-lo a longo prazo, mas é útil simplificar as operações e copiar dados.
O segundo número é o número de espaços que produziremos no início de cada linha, começando após a primeira linha. A primeira linha não terá espaços à esquerda.
O terceiro número é o caractere de espaço que produzimos.
O quarto número é um espaço reservado 255, para que possamos voltar a essa posição com relativa facilidade.

Entrada

Nesta posição, leremos todos os personagens. No final desta etapa, esperamos estar na seguinte situação:

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

Onde a b c d e f ...indica a sequência de caracteres numéricos que foi inserida (não a nova linha).

Conseguimos isso com o seguinte:

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

Existem algumas nuances para isso. Antes de tudo, produziremos cada caractere à medida que os obtivermos e, em seguida, produziremos um espaço após ele. Em segundo lugar, não queremos copiar o valor ASCII para a fita, queremos copiar o dígito numérico real. Terceiro, queremos parar quando atingimos uma nova linha e nos deixamos em um bom lugar naquele momento.
Digamos que nossa opinião seja 6723. Então, ao ler o primeiro 6, nossa fita fica assim:

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

Verificamos que esse valor não é igual a 10(uma nova linha ASCII) com ,----------[++++++++++. Em seguida, imprimimos o valor e continuamos subtraindo 48 do valor de entrada e adicionando 32 ao valor ao lado ( >>++++++++[-<++++<------>>]<), deixando-nos aqui:

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

Observe como, durante todo esse processo, podemos assumir que todos os dígitos à direita de nossa entrada são 0 - isso significa que não corremos o risco de arruinar qualquer estado anterior se usarmos valores à direita para calcular 6 * 8e 4 * 8.
Agora, produzimos o caractere de espaço que acabamos de gerar e recebemos uma nova entrada, excluindo o espaço que calculamos lá. Eventualmente, a entrada será finalizada por uma nova linha e o loop sairá, deixando um local 255onde a nova linha estaria ( ,----------]-). Este é o segundo caractere de espaço reservado que usaremos para navegar na fita. Neste ponto do nosso cenário, nossa fita é exatamente isso:

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

Cálculo

A maneira como isso funciona é que a lista de dígitos entre nossos 255espaços reservados diminui um a cada iteração do loop. Quando resta apenas um dígito, terminamos e devemos parar imediatamente (observe que, neste momento, todos os dígitos dessa lista já foram emitidos, portanto, não precisamos nos preocupar em produzi-lo novamente).

Vamos agora usar esse truque para navegar para o primeiro 255espaço reservado: <+[-<+]-. Isso efetivamente pesquisa a fita à esquerda em busca de um 255, não alterando nada no meio. Agora que movemos o ponteiro, podemos verificar nossa condição de saída: se houver apenas um dígito na lista, a célula dois espaços à direita serão mantidos 255. Assim, verificamos isso e iniciamos um loop:>>+[-<<

O primeiro passo no nosso loop é gerar uma nova linha. Então, passamos para a primeira célula (nossa célula tampão), adicionamos 10 a ela e produzimos. O próximo passo é gerar todos os caracteres de espaço iniciais. Depois de produzi-los, aumentamos nossa contagem para o número de espaços à esquerda. Essas etapas são realizadas pelo seguinte:

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

O que nos deixa nesse estado:

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

Nosso próximo passo é copiar o primeiro valor da lista, além do segundo espaço reservado 255:

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

Basicamente, fazemos isso alternando entre os espaços reservados 255, deixando-nos aqui:

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

Agora, iniciamos um loop, percorrendo o restante da lista, parando quando clicamos em 255:>+[-<

Nesse ponto, o dígito à nossa esquerda imediata é sempre 0. Portanto, como os amamos, colocamos um espaço reservado 255lá para que possamos voltar ao nosso lugar na lista. O próximo passo é mover o segundo lugar na lista para os locais ao redor de onde movemos o primeiro lugar, além do segundo espaço reservado 255. Essas etapas são realizadas pelo seguinte:

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

Deixando-nos aqui: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] Agora, ambos 6e 7foram movidos para um local onde o cálculo pode ocorrer. Precisamos de duas cópias do 7porque o próximo número da lista também precisará dele. O 7imediatamente após o 255serve a esse propósito, enquanto o outro 7será consumido pelo cálculo.

Primeiro, adicionamos os dois dígitos:

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

Deixando-nos aqui:

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

A próxima combinação de etapas é a mais complicada. Precisamos ver se o número para o qual estamos apontando é maior que 10 e, se for, subtraímos 10. Na realidade, o que fazemos é subtraí-lo 10 e ver se ele atinge 0algum ponto da subtração. Se isso acontecer, adicionamos 10novamente mais tarde. No final, devemos ter a soma do módulo 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

Neste ponto, alcançamos o objetivo. Nós temos a soma módulo 10! Além disso, independentemente de o número ser maior que 10, acabaremos aqui:

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

Nossos próximos objetivos são produzir essa nova soma, segui-la com um espaço e injetá-la novamente em nossa lista. Fazemos isso tudo com nossas técnicas anteriores de 255-hopping e adicionando 48à nossa soma, para que não seja abordado em detalhes.

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

E estamos aqui: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] observe como colocamos um 255espaço reservado adicional após a injeção recente, 3para não perder o lugar na lista. Neste ponto, produzimos nossa soma e seu espaço, portanto, precisamos limpar e reverter para um estado em que a próxima iteração desse loop funcione. Precisamos limpar nossas células 51e 32, mover 7uma vez para a direita e navegar para o espaço reservado da lista para que possamos começar de novo.

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

Agora, estamos aqui: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
que é exatamente onde queremos estar para a próxima iteração. Portanto, verifique 255 e siga em frente! ( >+])

Quando formos retirados do loop, teremos uma lista totalmente nova - composta pelas somas da lista anterior. A primeira vez, ficará assim:

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

Agora, queremos repetir todo esse processo em nossa nova lista, para que 255desça para a esquerda e recomeçemos! Precisamos fazer um pouco de limpeza e >>[-]<<, em seguida, deixar nosso espaço reservado com <-. Depois disso, estamos exatamente no mesmo lugar que estávamos após a entrada, para que possamos fazer as mesmas verificações: <+[-<+]->>+e boom! Temos todo o nosso ciclo! Todos necessidade que é o colchete de fechamento, e quando termina Nós já tudo de saída, de modo que estamos a fazer: ].

Geléia , 20 19 18 bytes

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

Experimente online!

fundo

A geração dos números é direta no Jelly. A saída é um pouco mais complicada.

O Jelly possui um átomo de grade embutido ( G) que exibe uma lista 2D com novas linhas entre linhas e espaços entre colunas. Pegamos a matriz de números 2D (gerada com cada linha invertida) e a transpomos com valor de preenchimento @. Após reverenciar a matriz resultante e transpor novamente, a aplicação Gproduz o seguinte.

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

Para obter a forma triangular desejada, basta remover o valor de preenchimento.

Como funciona

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

Pitão - 18 bytes

j.e+*dkjdbP.ueM+Vt

Conjunto de Teste .

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 bytes

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

Entrada é uma lista de números inteiros (por exemplo f([1,2,3,5,8])), a saída é para STDOUT. O %10fato de mapretornar um mapobjeto no Python 3 é um pouco chato, o que significa que não podemos fazer algo map(lambda*x:sum(x)%10,L,L[1:])parecido.

A função falha, mas então a saída já estava concluída. Graças a @xsot por -1 byte, encontrando um bom lugar para colocar o print.

05AB1E , 20 19 17 bytes

Código:

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

Explicaçã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.

Usa a codificação CP-1252 . Experimente online! .

MATL, 32 30 29 28 27 26 25 24 bytes

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

1 byte salvo graças a @Luis

Experimente Online!

Versão modificada para todos os casos de teste

Explicação

        % 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

Na verdade, 43 bytes

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

Experimente online!

Este programa imprime uma única linha nova à direita após a saída.

Explicação:

;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]&

Exemplo:

CJam, 25 bytes

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

Experimente online!

Explicação

Isso usa um truque bastante interessante para gerar o layout do triângulo.

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 bytes

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 bytes

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

Com base na resposta do @ Sp3000 . A função \aceita uma matriz como entrada e retorna uma string.

Experimente online!

Pyke, 21 bytes

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

Experimente aqui!

Eu gostaria de pensar que esse método é um pouco diferente.

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

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

Explicação:

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

Exemplo:

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 bytes

Ao usar o GOTO em vez de um dos WHILE, eu consegui jogar com 3 caracteres

Golfe

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

Experimente online (usando script antigo com 2 * WHILE)

Java 7, 230 215 213 bytes

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

Isso acabou sendo um pouco mais longo do que eu pensava .. Talvez possa ser um pouco mais jogado, já que eu meio que errei, acho ..

Alguns bytes salvos graças ao @GiacomoGarabello .

Ungolfed & código de teste:

Experimente aqui.

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

Saída:

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 bytes

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+" "):"");

O +18 é para using System.Linq;

Agradecemos a @TheLethalCoder por salvar 13 bytes, apontando uma declaração de utilização desnecessária

JavaScript (ES6), 77 bytes

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

C, 138 bytes

Golfe

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 bytes

Na verdade, estou muito orgulhoso dessa solução, as expressões lambda são tão divertidas quando você pega o jeito delas

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

aqui ungolfed para mais melhorias:

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

experimente aqui

Haskell, 139 bytes

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)

Pega a entrada como argumento e gera para STDOUT.

Versão não destruída:

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 bytes

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

Imprime uma única nova linha à direita.

Como funciona

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

Experimente no Ideone

J, 44 bytes

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

Com base nesta solução .

Javascript (usando biblioteca externa) (198 bytes)

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}

Link para lib: https://github.com/mvegh1/Enumerable/

Explicação do código: Foi fácil usar a biblioteca! Não ganha em bytes, mas o código não é muito detalhado e fácil de ler. Portanto, a entrada "n 'é uma matriz de números inteiros. Carregue-a na biblioteca, armazenada na variável" a "." B "é a string de retorno, armazene a string unida com" "como delimitador em b. C é o iteração atual, use isso para determinar o número de espaços a serem inseridos.OBSERVAÇÃO: Isso parece funcionar bem quando a entrada é de 0 a 9. Em seguida, enquanto verdadeiro, repita um determinado conjunto de códigos. conjuntos do enumerável atual "a", ou seja, se tivermos [1,2,3,4,5,6] obteremos [1,2], [2,3], [3,4], ... [ 6] ... então filtre isso para termos apenas os lotes de tamanho 2. Em seguida, mapeamos isso para uma coleção das somas dos lotes% 10. Se a estiver vazio, estamos prontos, caso contrário, adicionamos a nova linha ao nosso retorno. Finalmente retorne ...

Imagem chegando em alguns minutos.