Eine Differenzpyramide ist eine Pyramide, bei der jede neue Diagonale der absolute Wert der Differenzen zwischen den Elementen der letzten Diagonale ist. Zum Beispiel, wenn wir mit dem Array beginnen

2 5 4 9 3 4

Nun ordnen wir diese in einer diagonalen Spalte an:

     2
      5
       4
        9
         3
          4

Jetzt füllen wir die nächste Diagonale aus. Die absoluten Unterschiede zwischen den aufeinanderfolgenden Elementen dieses Arrays sind:

3 1 5 6 1

Das ist also unsere nächste Diagonale.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Wiederholen, bis die Pyramide gefüllt ist:

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

Die Herausforderung

Erstellen Sie anhand einer Liste positiver Ganzzahlen im Bereich [0, 9]diese ASCII-Darstellung der Differenzpyramide für das jeweilige Array. Die Eingabe enthält garantiert mindestens zwei Elemente. Sie können diese Zahlen in jedem vernünftigen Format verwenden. (Array / Liste / wie auch immer Sie es nennen, ein String, Befehlszeilenargumente usw.) Nachgestellte Leerzeichen in jeder Zeile und bis zu einer nachgestellten neuen Zeile sind zulässig.

Testen Sie 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

Wie üblich ist dies Codegolf, daher gelten Standardlücken und die kürzeste Antwort in Bytes gewinnt!

Inspiriert von diesem OEIS und dieser Vermutung .

Gelee , 16 Bytes

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

Probieren Sie es online!

Hintergrund

Das Generieren der Unterschiede ist ganz einfach. Zur Eingabe

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

IA$Ṗп (Absolutwert von Inkrementen, wenn mehr als ein Element vorhanden ist) ergibt das folgende zackige 2D-Array.

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

UKehrt die Reihenfolge der Spalten und Ṛder Zeilen um und ergibt Folgendes.

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

Jetzt transponieren wir Zeilen und Spalten mit z”@, wodurch alle Zeilen vor dem Transponieren auf die gleiche Länge aufgefüllt werden. Das Ergebnis ist das Folgende.

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

Das Umkehren der Zeilen ergibt

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

Um das 2D-Array in eine durch Leerzeichen getrennte Zeichenfolge umzuwandeln, verwenden wir das integrierte Gitter atom ( G). Es verbindet Spalten durch Leerzeichen und Zeilen durch Zeilenvorschübe und ergibt das folgende Ergebnis.

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

Alles, was zu tun bleibt, ist, das Füllzeichen mit zu entfernen ḟ”@und nachzugeben

        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

Welches ist die gewünschte Ausgabe.

CJam, 29 Bytes

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

Probieren Sie es online! (Die erste und letzte Zeile ermöglichen eine durch Zeilenvorschub getrennte Testsuite.)

Dies verwendet den Dreiecksrotations- und Layoutcode aus dieser Antwort und das Dreieck selbst wird nach dem gleichen Prinzip wie in dieser Antwort generiert .

J, 46 42 39 36 Bytes

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

Eine unkomplizierte Umsetzung. Erzeugt eine Tabelle mit aufeinanderfolgenden Unterschieden zwischen jedem Paar und wiederholt sie so oft, wie es der Länge des Eingabearrays entspricht. Durchquert dann jede Diagonale dieser Tabelle, um die Zeilen des Dreiecks zu bilden. Der Rest formatiert die Zeilen zu einer Pyramide.

Verwendung

   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

Erläuterung

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

Probieren Sie es 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])

Eine Funktion, die die Eingabe einer Liste übernimmt x über ein Argument eingibt und das Ergebnis an STDOUT ausgibt.

Wie es funktioniert

Das Programm nimmt die Eingabe einer Liste vor xund initialisiert eine verschachtelte Liste yso, dass y[0] = x. Die absoluten Differenzen für die letzte Liste in y(anfangs x) werden dann erzeugt und als Liste angehängt, ybis eine Liste der Länge 1erreicht ist; In jeder Phase wird die Liste mit Leerzeichen aufgefüllt, sodass alle Listen in yderselben Länge wie sind x. Nächster,y wird transponiert, wobei es ein Tupel für jede Ausgabezeile enthält, jedoch umgekehrt. Jedes Tupel in der Transponierung wird ausgepackt, umgekehrt und gedruckt, wobei die Differenzpyramide auf STDOUT verbleibt.

Probieren Sie es auf Ideone