Una pirámide de diferencia es una pirámide donde cada nueva diagonal es el valor absoluto de las diferencias entre los elementos de la última diagonal. Por ejemplo, si comenzamos con la matriz

2 5 4 9 3 4

Ahora, los organizamos en una columna diagonal:

     2
      5
       4
        9
         3
          4

Ahora, completamos la siguiente diagonal. Las diferencias absolutas entre los elementos consecutivos de esta matriz son:

3 1 5 6 1

Entonces esa es nuestra próxima diagonal.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Repita hasta completar la pirámide:

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

El reto

Dada una lista de enteros positivos en el rango [0, 9], genere esta representación ASCII-art de la pirámide de diferencia para esa matriz en particular. Se garantiza que la entrada contiene al menos dos elementos. Puede tomar estos números en cualquier formato razonable. (Array / list / como se llame, una cadena, argumentos de línea de comando, etc.) Se permiten espacios finales en cada línea y hasta una nueva línea final.

Prueba IO

[1, 2, 3, 4, 5, 6, 7, 8, 9]

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

[4, 7]

 4
3 7

[3, 3, 3]

  3
 0 3
0 0 3

[1, 3, 6, 3, 4, 9]

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


[8, 7, 3, 2, 4, 5, 9, 1, 6]

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

Como de costumbre, este es el código de golf, por lo que se aplican las lagunas estándar, ¡y la respuesta más corta en bytes gana!

Inspirado por este OEIS y esta conjetura .

Jalea , 16 bytes

IA$ṖпUṚz”@ṚGḟ”@

Pruébalo en línea!

Antecedentes

Generar las diferencias es bastante sencillo. Para la entrada

[1, 2, 3, 4, 5, 6, 7, 8, 9]

IA$Ṗп (valor absoluto de incrementos mientras haya más de un elemento) produce la siguiente matriz 2D irregular.

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 1, 1, 1, 1, 1, 1, 1]
[0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0]
[0, 0]
[0]

Uinvierte el orden de las columnas y Ṛel orden de las filas, produciendo lo siguiente.

[0]
[0, 0]
[0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

Ahora, transponemos filas y columnas con z”@, que rellena todas las filas a la misma longitud antes de transponer. El resultado es el siguiente.

[0, 0, 0, 0, 0, 0, 0, 1, 9]
[@, 0, 0, 0, 0, 0, 0, 1, 8]
[@, @, 0, 0, 0, 0, 0, 1, 7]
[@, @, @, 0, 0, 0, 0, 1, 6]
[@, @, @, @, 0, 0, 0, 1, 5]
[@, @, @, @, @, 0, 0, 1, 4]
[@, @, @, @, @, @, 0, 1, 3]
[@, @, @, @, @, @, @, 1, 2]
[@, @, @, @, @, @, @, @, 1]

Invertir las filas da

[@, @, @, @, @, @, @, @, 1]
[@, @, @, @, @, @, @, 1, 2]
[@, @, @, @, @, @, 0, 1, 3]
[@, @, @, @, @, 0, 0, 1, 4]
[@, @, @, @, 0, 0, 0, 1, 5]
[@, @, @, 0, 0, 0, 0, 1, 6]
[@, @, 0, 0, 0, 0, 0, 1, 7]
[@, 0, 0, 0, 0, 0, 0, 1, 8]
[0, 0, 0, 0, 0, 0, 0, 1, 9]

Para convertir la matriz 2D en una cadena separada por espacios en blanco, utilizamos el átomo de cuadrícula incorporado ( G). Une columnas por espacios y filas por avances de línea, produciendo el siguiente resultado.

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

Todo lo que queda por hacer es eliminar el carácter de relleno ḟ”@, produciendo

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

cual es el resultado deseado.

CJam, 29 bytes

q~{_2ew::-:z}h]W%zzeeSff*W%N*

Pruébalo en línea! (La primera y la última línea habilitan un conjunto de pruebas separadas por salto de línea).

Utiliza el código de diseño y rotación de triángulos de esta respuesta y el triángulo mismo se genera con el mismo principio que en esta respuesta .

J, 46 42 39 36 bytes

(#\-#)|."_1#{.[:":@|./.<@#2&(|@-/\)]

Una implementación directa. Genera una tabla de diferencias sucesivas entre cada par y la repite varias veces igual a la longitud de la matriz de entrada. Luego atraviesa cada diagonal de esa tabla para formar las filas del triángulo. El resto es formatear las filas en una pirámide.

Uso

   f =: (#\-#)|."_1#{.[:":@|./.<@#2&(|@-/\)]
   f 2 5 4 9 3 4
     2     
    3 5    
   2 1 4   
  2 4 5 9  
 1 3 1 6 3 
0 1 4 5 1 4
   f 4 7
 4 
3 7
   f 8 7 3 2 4 5 9 1 6
        8        
       1 7       
      3 4 3      
     0 3 1 2     
    2 2 1 2 4    
   0 2 0 1 1 5   
  0 0 2 2 3 4 9  
 1 1 1 1 1 4 8 1 
0 1 0 1 0 1 3 5 6

Explicación

(#\-#)|."_1#{.[:":@|./.<@#2&(|@-/\)]  Input: list A
                         #            Get len(A)
                       <@             Box it
                                   ]  Get A
                          2&(     )   Repeat len(A) times on A initially
                          2      \      Get each iverlapping sublist of size 2
                                /       Reduce it using
                             |@-          The absolute value of the difference

                                      This will form a table where each row contains the
                                      successive differences
              [:     /.               Operate on the diagonals of that table
                   |.                 Reverse each diagonal
                ":@                   Format each into a string
           #                          Get len(A)
            {.                        Take that many from the strings of diagonals
 #\                                   Get the length of each prefix of A
                                      Makes the range [1, 2, ..., len(A)]
    #                                 Get len(A)
   -                                  Subtract the len(A) from each in the prefix range
                                      Makes [-len(A)+1, ..., -1, 0]
      |."_1                           Rotate each string left using each value
                                      A negative rotate left = rotate right
                                      Output the pyramid

Pyth, 22 bytes

jmX-jN_Pd;N;_.t_M.uaVt

Pruébalo en línea!

Python 3, 144 bytes

def f(x):
 y=[x]
 for i in range(len(x)-1):y+=[['']*-~i+[abs(y[i][j]-y[i][j+1])for j in range(i,len(y[i])-1)]]
 for i in zip(*y):print(*i[::-1])

Una función que toma la entrada de una lista a xtravés de un argumento e imprime el resultado en STDOUT.

Cómo funciona

El programa toma la entrada de una lista xe inicializa una lista anidada ytal que y[0] = x. Las diferencias absolutas para la última lista en y(inicialmente x) se generan y se agregan como una lista yhasta que 1se alcanza una lista de longitud ; en cada etapa, la lista se rellena previamente con espacios para que todas las listas ytengan la misma longitud que x. A continuación, yse transpone, dejándolo con una tupla para cada línea de salida, pero se invierte. Cada tupla en la transposición se desempaqueta, invierte e imprime, dejando la pirámide de diferencia en STDOUT.

Pruébalo en Ideone