Une pyramide des différences est une pyramide où chaque nouvelle diagonale est la valeur absolue des différences entre les éléments de la dernière diagonale. Par exemple, si nous commençons par le tableau

2 5 4 9 3 4

Maintenant, nous les organisons dans une colonne diagonale:

     2
      5
       4
        9
         3
          4

Maintenant, nous remplissons la diagonale suivante. Les différences absolues entre les éléments consécutifs de ce tableau sont:

3 1 5 6 1

Voilà donc notre prochaine diagonale.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Répétez jusqu'à ce que la pyramide soit remplie:

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

Le défi

Étant donné une liste d'entiers positifs dans la plage [0, 9], générez cette représentation ASCII de la pyramide des différences pour ce tableau particulier. L'entrée est garantie pour contenir au moins deux éléments. Vous pouvez prendre ces numéros dans n'importe quel format raisonnable. (Tableau / liste / quel que soit votre nom, une chaîne, des arguments de ligne de commande, etc.) Les espaces de fin sur chaque ligne et jusqu'à une nouvelle ligne de fin sont autorisés.

Test 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

Comme d'habitude, il s'agit de code-golf, donc les lacunes standard s'appliquent, et la réponse la plus courte en octets gagne!

Inspiré par cet OEIS et cette conjecture .

Gelée , 16 octets

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

Essayez-le en ligne!

Contexte

Générer les différences est assez simple. Pour entrée

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

IA$Ṗп (valeur absolue des incréments lorsqu'il existe plusieurs éléments) donne le tableau 2D irrégulier suivant.

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

Uinverse l'ordre des colonnes et Ṛl'ordre des lignes, ce qui donne ce qui suit.

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

Maintenant, nous transposons les lignes et les colonnes avec z”@, qui remplissent toutes les lignes à la même longueur avant la transposition. Le résultat est le suivant.

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

Inverser les lignes donne

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

Pour transformer le tableau 2D en une chaîne séparée par des espaces, nous utilisons l'atome de grille intégré ( G). Il joint les colonnes par des espaces et les lignes par des sauts de ligne, donnant le résultat suivant.

@ @ @ @ @ @ @ @ 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

Il ne reste plus qu'à supprimer le caractère de remplissage avec ḟ”@, ce qui donne

        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

qui est la sortie souhaitée.

CJam, 29 octets

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

Essayez-le en ligne! (La première et la dernière ligne activent une suite de tests séparés par un saut de ligne.)

Cela utilise le code de rotation et de mise en page du triangle de cette réponse et le triangle lui-même est généré avec le même principe que dans cette réponse .

J, 46 42 39 36 octets

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

Une implémentation simple. Génère un tableau des différences successives entre chaque paire et le répète un nombre de fois égal à la longueur du tableau d'entrée. Traverse ensuite chaque diagonale de ce tableau pour former les rangées du triangle. Le reste met en forme les lignes dans une pyramide.

Usage

   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

Explication

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

jmX-jN_Pd;N;_.t_M.uaVt

Essayez-le en ligne!

Python 3, 144 octets

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

Une fonction qui prend l'entrée d'une liste xvia un argument et imprime le résultat dans STDOUT.

Comment ça fonctionne

Le programme prend l'entrée d'une liste xet initialise une liste imbriquée ytelle que y[0] = x. Les différences absolues pour la dernière liste dans y(initialement x) sont ensuite générées et ajoutées sous forme de liste jusqu'à yce qu'une liste de longueur 1soit atteinte; à chaque étape, la liste est pré-remplie avec des espaces de sorte que toutes les listes yaient la même longueur que x. Ensuite, yest transposé, le laissant contenant un tuple pour chaque ligne de sortie, mais inversé. Chaque tuple dans la transposition est déballé, inversé et imprimé, laissant la pyramide des différences sur STDOUT.

Essayez-le sur Ideone