Bueno, resumirlo realmente.

Escriba un programa o función que tome una lista no vacía de enteros decimales (0-9) y genere un "triángulo" de dígitos apuntando hacia abajo con la lista de entrada en la parte superior donde cada dígito después de la primera línea es la suma de los dos dígitos encima de él módulo 10.

Por ejemplo, la entrada [7, 5, 0, 9]tiene salida

7 5 0 9
 2 5 9
  7 4
   1

porque 2es (7 + 5) mod 10, 5es (5 + 0) mod 10, 9es (0 + 9) mod 10, etc. todo el camino hacia el 1ser (7 + 4) mod 10.

Si la lista tiene solo un elemento, la salida coincide con la entrada; Por ejemplo, una entrada de [4]producirá

4

Aquí hay algunos ejemplos adicionales:

[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

Tenga en cuenta que en la salida:

• La primera línea no tiene espacios iniciales.
• Cada línea posterior tiene un espacio inicial más que la línea anterior.
• Los dígitos están separados por un solo espacio.
• Cada línea puede tener hasta un espacio final.
• Puede haber una sola línea final opcional.
• Debe usar los caracteres para dígitos decimales normales (0 a 9).

El código más corto en bytes gana. Tiebreaker es la respuesta anterior.

BrainF ** k, 396 391 bytes

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

No pude resistir la tentación de hacer esto. Al menos el triángulo tiene el lado puntiagudo hacia abajo.

La entrada viene como una cadena de caracteres numéricos seguidos de una nueva línea nueva.

La salida contendrá un solo espacio final en cada línea.

Ejemplos:

$ 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 

Explicación

Dado que es bastante difícil explicar el código desde una perspectiva funcional, podemos verlo desde la perspectiva del estado de la cinta en varios momentos. La idea central aquí es que el triángulo que generamos se inicializa como una matriz muy compacta (para BF, de todos modos) que se reduce en tamaño en 1 cada iteración de un bucle. Otro pensamiento importante es que usamos 255para indicar un "marcador de posición" que podemos buscar en la cinta.

Inicialización

Este es el paso más fácil. Al comienzo del programa, ejecutamos lo siguiente:

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

Esto fuerza a la cinta al siguiente estado (donde >N<indica la ubicación del puntero en la cinta)

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

El primer número aquí es una ubicación de "búfer". No lo vamos a utilizar a largo plazo, pero es útil para simplificar las pequeñas operaciones y para copiar datos.
El segundo número es el número de espacios que generaremos al comienzo de cada línea, comenzando después de la primera línea. La primera línea no tendrá espacios iniciales.
El tercer número es el carácter de espacio que mostramos.
El cuarto número es un marcador de posición 255, por lo que podemos volver a esta posición con relativa facilidad.

Entrada

Desde esta posición, leeremos todos los personajes. Al final de este paso, esperamos estar en la siguiente situación:

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

Donde a b c d e f ...indica la cadena de caracteres numéricos que se ingresó (no la nueva línea).

Logramos esto con lo siguiente:

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

Hay algunos matices en esto. En primer lugar, mostraremos cada carácter a medida que los obtengamos, y luego mostraremos un espacio después. En segundo lugar, no queremos copiar el valor ASCII en la cinta, queremos copiar el dígito numérico real. Tercero, queremos detenernos cuando lleguemos a una nueva línea y dejarnos en un buen lugar en ese momento.
Digamos que nuestra entrada es 6723. Luego, al leer el primero 6, nuestra cinta se ve así:

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

Verificamos que este valor no sea igual a 10(una nueva línea ASCII) con ,----------[++++++++++. Luego imprimimos el valor y continuamos restando simultáneamente 48 del valor de entrada y sumando 32 al valor al lado ( >>++++++++[-<++++<------>>]<), dejándonos aquí:

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

Observe cómo a lo largo de este proceso podemos suponer que todos los dígitos a la derecha de nuestra entrada son 0; esto significa que no estamos en peligro de arruinar ningún estado anterior si usamos valores a la derecha para calcular 6 * 8y 4 * 8.
Ahora sacamos el carácter de espacio que acabamos de generar y tomamos una nueva entrada, eliminando el espacio que calculamos allí. Eventualmente, la entrada será terminada por una nueva línea y el ciclo saldrá, dejando un lugar 255donde la nueva línea habría estado ( ,----------]-). Este es el segundo carácter de marcador de posición que utilizaremos para navegar por la cinta. En este punto de nuestro escenario, nuestra cinta es exactamente esto:

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

Cálculo

La forma en que esto funciona es que la lista de dígitos entre nuestros 255marcadores de posición se reducirá en uno cada iteración del bucle. Cuando solo le queda 1 dígito, hemos terminado y deberíamos detenernos de inmediato (tenga en cuenta que, en este punto, cada dígito de esa lista ya se ha generado, por lo que no tenemos que preocuparnos por volver a generarlo).

Ahora utilizamos este truco para navegar hasta el primer 255marcador de posición: <+[-<+]-. Esto efectivamente busca en la cinta a la izquierda un 255, sin cambiar nada en el medio. Ahora que hemos movido el puntero, podemos verificar nuestra condición de salida: si solo hay un dígito en la lista, entonces se mantendrán los dos espacios de la celda a la derecha 255. Por lo tanto, verificamos eso y comenzamos un ciclo:>>+[-<<

El primer paso en nuestro bucle es generar una nueva línea. Entonces nos movemos a la primera celda (nuestra celda de búfer), le agregamos 10 y salimos. El siguiente paso es generar todos los caracteres de espacio iniciales. Después de generarlos, incrementamos nuestra cuenta para el número de espacios iniciales. Estos pasos se logran de la siguiente manera:

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

Lo que nos deja en este estado:

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

Nuestro siguiente paso es copiar el primer valor de la lista, más allá del segundo marcador de posición 255:

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

Esencialmente hacemos esto saltando de un lado a otro entre nuestros marcadores de posición 255, dejándonos aquí:

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

Ahora comenzamos un ciclo, iterando por el resto de la lista, deteniéndonos cuando tocamos 255:>+[-<

En este punto, el dígito a nuestra izquierda inmediata siempre es 0. Entonces, como los amamos, colocamos un marcador 255de posición allí para que podamos volver a nuestro lugar en la lista. El siguiente paso es mover el segundo lugar de la lista a las ubicaciones que rodean a donde movimos el primer lugar, más allá del segundo marcador de posición 255. Estos pasos se logran de la siguiente manera:

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

Dejándonos aquí: [ 0 2 32 255 255 >0< 2 3 255 7 6 7 0 ] ahora, tanto el 6y 7se han movido a una ubicación donde puede ocurrir el cálculo. Necesitamos dos copias del 7porque el siguiente número de la lista también lo necesitará. El 7inmediatamente posterior al 255sirve para este propósito, mientras que el otro 7será consumido por el cálculo.

Primero, agregamos los dos dígitos:

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

Dejándonos aquí:

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

La siguiente combinación de pasos es la más complicada. Necesitamos ver si el número al que apuntamos es mayor que 10, y si es así, restamos 10. En realidad, lo que hacemos es restarle 10 y ver si llega 0a algún punto de la resta. Si es así, agregamos 10nuevamente más tarde. Al final de esto, deberíamos tener la suma 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
>>+[-<<<+>>>[-<->]<+++++++++>>>+]

En este punto, hemos logrado el objetivo. ¡Tenemos la suma módulo 10! Además, ya sea que el número sea mayor que 10, terminaremos aquí:

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

Nuestros próximos objetivos son generar esta nueva suma, seguirla con un espacio e inyectarla nuevamente en nuestra lista. Hacemos todo esto con nuestras técnicas anteriores de 255salto y adición 48a nuestra suma, por lo que no lo cubriré en detalle.

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

Y estamos aquí: [ 0 2 32 255 3 255 2 3 255 7 0 0 51 >32< ] observe cómo colocamos un 255marcador de posición adicional después de nuestro recién inyectado 3para que no perdamos lugar en la lista. En este punto, hemos generado nuestra suma y su espacio, por lo que debemos limpiar y volver a un estado en el que la próxima iteración de este bucle vaya a funcionar. Necesitamos limpiar nuestro 51y32 celdas , mover la 7una vez a la derecha y navegar a nuestro marcador de posición de lista para que podamos comenzar de nuevo.

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

Ahora estamos aquí: [ 0 2 32 255 3 >0< 2 3 255 0 7 0 ... ]
que es exactamente donde queremos estar para nuestra próxima iteración. ¡Así que verifique 255 y siga adelante! ( >+])

Cuando nos retiremos del ciclo, tendremos una lista completamente nueva, compuesta de las sumas de la lista anterior. La primera vez, se verá así:

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

Ahora queremos repetir todo el proceso en nuestra nueva lista, ¡así que dejamos 255caer a la izquierda y comenzamos de nuevo! Necesitamos hacer un poco de limpieza >>[-]<<y luego quitar nuestro marcador de posición <-. Después de eso, estamos exactamente en el mismo lugar donde estábamos después de la entrada, por lo que podemos hacer las mismas verificaciones: ¡ <+[-<+]->>+y boom! ¡Tenemos nuestro circuito completo! Todo lo que necesitamos es el corchete de cierre, y cuando termina todo lo que ya hemos de salida, por lo que hemos terminado: ].

Jalea , 20 19 18 bytes

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

Pruébalo en línea!

Fondo

Generar los números es sencillo en Jelly. La salida es un poco más complicada.

Jelly tiene un átomo de cuadrícula incorporado ( G) que muestra una lista 2D con nuevas líneas entre filas y espacios entre columnas. Tomamos la matriz 2D de números (generados con cada fila invertida) y la transponemos con el valor de relleno @. Después de revertir la matriz resultante y transponer nuevamente, la aplicación Gproduce lo siguiente.

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 obtener la forma triangular deseada, todo lo que tenemos que hacer es eliminar el valor de relleno.

Cómo 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.

Pyth - 18 bytes

j.e+*dkjdbP.ueM+Vt

Test Suite .

j                                       Join by newlines
 .e                                     Loop over seq in var b and index in var k
  +                                     Concatenate
   *dk                                  Space repeated k times
    jdb                                 Join b by spaces
  P                                     [:-1] to get rid of empty line
   .u             (Q implicit)          Cumulative fixed point over input (var G)
    eM                                  Mod 10 mapped over list
     +V                                 Vectorized addition
      t(G implict)                      G[1:]
      (G implict)                       Vectorize cuts this off to G[:-1]

Python 3.5, 74 72 71 bytes

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

La entrada es una lista de enteros (p f([1,2,3,5,8]). Ej. ), La salida es STDOUT. El %10hecho de que mapdevuelva un mapobjeto en Python 3 es un poco molesto, lo que significa que no podemos hacer nada map(lambda*x:sum(x)%10,L,L[1:])similar.

La función falla, pero para entonces la salida se habría completado. Gracias a @xsot por -1 byte al encontrar un buen lugar para pegar el print.

05AB1E , 20 19 17 bytes

Código:

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

Explicación:

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.

Utiliza la codificación CP-1252 . Pruébalo en línea! .

MATL, 32 30 29 28 27 26 25 24 bytes

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

1 Byte guardado gracias a @Luis

Pruébalo en línea!

Versión modificada para todos los casos de prueba.

Explicación

        % 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

En realidad, 43 bytes

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

Pruébalo en línea!

Este programa imprime una nueva línea final después de la salida.

Explicación:

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

Ejemplo:

CJam, 25 bytes

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

Pruébalo en línea!

Explicación

Esto utiliza un truco bastante bueno para generar el diseño del 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)

Basado en la respuesta de @ Sp3000 . La función \acepta una matriz como entrada y devuelve una cadena.

Pruébalo en línea!

Pyke, 21 bytes

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

Pruébalo aquí!

Me gustaría pensar que este método es un poco 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}

Explicación:

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

Ejemplo:

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

Al usar GOTO en lugar de uno de WHILE, pude jugar golf a 3 personajes

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

Pruébelo en línea (usando un script antiguo con 2 * MIENTRAS)

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

Esto terminó siendo un poco más de lo que pensaba ... Tal vez se pueda jugar un poco más al golf, ya que creo que me equivoqué un poco ...

Algunos bytes guardados gracias a @GiacomoGarabello .

Ungolfed y código de prueba:

Pruébalo aquí

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

Salida:

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

El +18 es para using System.Linq;

Gracias a @TheLethalCoder por guardar 13 bytes, al señalar una declaración de uso innecesario

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

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

Sin golf

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

De hecho, estoy bastante orgulloso de esta solución, las expresiones lambda son muy divertidas una vez que las dominas

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

aquí sin pretensiones para nuevas mejoras:

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

pruébalo aquí

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)

Toma la entrada como argumento, las salidas a STDOUT.

Versión sin golf:

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 una línea nueva final.

Cómo 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

Pruébalo en Ideone

J, 44 bytes

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

Basado en esta solución .

Javascript (usando una 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}

Enlace a lib: https://github.com/mvegh1/Enumerable/

Explicación del código: ¡Fue fácil usar la biblioteca! No gana en bytes, pero el código no es demasiado detallado y fácil de leer. Por lo tanto, la entrada "n 'es una matriz de enteros. Cárguelo en la biblioteca, almacenado en la variable" a "." B "es la cadena de retorno, almacene la cadena unida con" "como delimitador en b. C es el iteración actual, use esto para determinar el número de espacios para insertar. NOTA: Esto solo parece funcionar bien cuando la entrada es de 0 a 9. Luego, mientras es verdadero, repita un cierto conjunto de código. Ese código es para crear un lote adyacente conjuntos de la "a" actual enumerable, es decir, si tenemos [1,2,3,4,5,6] obtenemos [1,2], [2,3], [3,4], ... [ 6] ... luego filtre eso para que solo tengamos los lotes de tamaño 2. Luego lo asignamos a una colección de las sumas de los lotes% 10. Si a está vacío, hemos terminado, de lo contrario, agregamos la nueva línea a nuestro regreso. Finalmente regreso ...

La imagen viene en unos minutos.