Uma pirâmide de diferença é uma pirâmide em que cada nova diagonal é o valor absoluto das diferenças entre os elementos da última diagonal. Por exemplo, se começarmos com a matriz

2 5 4 9 3 4

Agora, organizamos isso em uma coluna diagonal:

     2
      5
       4
        9
         3
          4

Agora, preenchemos a próxima diagonal. As diferenças absolutas entre os elementos consecutivos dessa matriz são:

3 1 5 6 1

Então essa é a nossa próxima diagonal.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Repita até que a pirâmide seja preenchida:

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

O desafio

Dada uma lista de números inteiros positivos no intervalo [0, 9], gere essa representação em arte ASCII da pirâmide da diferença para esse array em particular. A entrada é garantida para conter pelo menos dois elementos. Você pode levar esses números em qualquer formato razoável. (Matriz / lista / como você chama, uma string, argumentos de linha de comando, etc.) São permitidos espaços à direita em cada linha e até uma nova linha à direita.

Teste de E / S

[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 costume, esse é um código de golfe, então as brechas padrão se aplicam e a resposta mais curta em bytes ganha!

Inspirado por este OEIS e esta conjectura .

Gelatina , 16 bytes

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

Experimente online!

fundo

Gerar as diferenças é bastante direto. Para entrada

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

IA$Ṗп (valor absoluto de incrementos enquanto houver mais de um elemento) gera a seguinte 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]

Uinverte a ordem das colunas e Ṛa ordem das linhas, produzindo o seguinte.

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

Agora, transpomos linhas e colunas com z”@, que preenchem todas as linhas do mesmo comprimento antes da transposição. O resultado é o seguinte.

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

Inverter as linhas dá

[@, @, @, @, @, @, @, @, 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 transformar a matriz 2D em uma sequência separada por espaço em branco, usamos o átomo de grade interno ( G). Une colunas por espaços e linhas por feeds de linha, produzindo o seguinte 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

Tudo o que resta a fazer é remover o caractere de preenchimento ḟ”@, produzindo

        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

qual é a saída desejada.

CJam, 29 bytes

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

Experimente online! (A primeira e a última linha ativam um conjunto de testes separado por avanço de linha.)

Isso usa o código de rotação e layout do triângulo desta resposta e o próprio triângulo é gerado com o mesmo princípio que nesta resposta .

J, 46 42 39 36 bytes

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

Uma implementação direta. Gera uma tabela de diferenças sucessivas entre cada par e a repete várias vezes igual ao comprimento da matriz de entrada. Em seguida, percorre cada diagonal da tabela para formar as linhas do triângulo. O resto está formatando as linhas em uma 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

Explicação

(#\-#)|."_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

Pitão, 22 bytes

jmX-jN_Pd;N;_.t_M.uaVt

Experimente online!

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

Uma função que recebe entrada de uma lista x por meio de argumento e imprime o resultado em STDOUT.

Como funciona

O programa recebe a entrada de uma lista xe inicializa uma lista aninhada ycomo essa y[0] = x. As diferenças absolutas para a última lista em y(inicialmente x) são geradas e anexadas como uma lista yaté que uma lista de tamanho 1seja atingida; em cada estágio, a lista é preenchida previamente com espaços para que todas as listas ytenham o mesmo comprimento que x. Em seguida, yé transposta, deixando-a contendo uma tupla para cada linha de saída, mas invertida. Cada tupla na transposição é descompactada, revertida e impressa, deixando a pirâmide da diferença em STDOUT.

Experimente no Ideone