Una piramide delle differenze è una piramide in cui ogni nuova diagonale è il valore assoluto delle differenze tra gli elementi dell'ultima diagonale. Ad esempio, se iniziamo con l'array

2 5 4 9 3 4

Ora, disponiamo questi in una colonna diagonale:

     2
      5
       4
        9
         3
          4

Ora riempiamo la prossima diagonale. Le differenze assolute tra gli elementi consecutivi di questo array sono:

3 1 5 6 1

Quindi questa è la nostra prossima diagonale.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Ripeti fino a quando la piramide non viene riempita:

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

La sfida

Dato un elenco di numeri interi positivi nell'intervallo [0, 9], genera questa rappresentazione in arte ASCII della piramide delle differenze per quel particolare array. È garantito che l'input contenga almeno due elementi. Puoi prendere questi numeri in qualsiasi formato ragionevole. (Matrice / elenco / come la chiami, una stringa, argomenti della riga di comando, ecc.) Sono consentiti spazi finali su ciascuna riga e fino a una nuova riga finale.

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

Come al solito, si tratta di code-golf, quindi si applicano scappatoie standard e vince la risposta più breve in byte!

Ispirato da questo OEIS e da questa congettura .

Gelatina , 16 byte

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

Provalo online!

sfondo

Generare le differenze è abbastanza semplice. Per input

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

IA$Ṗп (valore assoluto degli incrementi mentre è presente più di un elemento) produce il seguente array 2D irregolare.

[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 l'ordine delle colonne e Ṛl'ordine delle righe, producendo quanto segue.

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

Ora trasponiamo le righe e le colonne con z”@, che pad tutte le righe della stessa lunghezza prima di trasporre. Il risultato è il seguente.

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

Si inverte le righe

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

Per trasformare l'array 2D in una stringa separata da spazi bianchi, utilizziamo l'atomo di griglia incorporato ( G). Unisce colonne per spazi e righe per avanzamenti di riga, producendo il seguente risultato.

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

Tutto ciò che resta da fare è rimuovere il carattere di riempimento con ḟ”@, cedendo

        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

quale è l'output desiderato.

CJam, 29 byte

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

Provalo online! (La prima e l'ultima riga abilitano una suite di test separata da avanzamento riga.)

Questo utilizza il codice di rotazione del triangolo e layout da questa risposta e il triangolo stesso viene generato con lo stesso principio di questa risposta .

J, 46 42 39 36 byte

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

Un'implementazione diretta. Genera una tabella di differenze successive tra ciascuna coppia e la ripete un numero di volte uguale alla lunghezza dell'array di input. Quindi attraversa ogni diagonale di quella tabella per formare le file del triangolo. Il resto sta formattando le righe in una piramide.

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

Spiegazione

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

jmX-jN_Pd;N;_.t_M.uaVt

Provalo online!

Python 3, 144 byte

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 funzione che accetta l'input di un elenco x tramite argomento e stampa il risultato su STDOUT.

Come funziona

Il programma accetta l'input di un elenco xe inizializza un elenco nidificato in ymodo tale y[0] = x. Le differenze assolute per l'ultimo elenco in y(inizialmente x) vengono quindi generate e aggiunte come un elenco yfino a quando non 1viene raggiunto un elenco di lunghezza ; in ogni fase, l'elenco è pre-riempito con spazi in modo tale che tutti gli elenchi yabbiano la stessa lunghezza di x. Successivamente, yviene trasposto, lasciandolo contenente una tupla per ogni linea di output, ma invertito. Ogni tupla nella trasposizione è spacchettata, invertita e stampata, lasciando la piramide della differenza su STDOUT.

Provalo su Ideone