Piramida różnicowa to piramida, w której każda nowa przekątna jest wartością bezwzględną różnic między elementami ostatniej przekątnej. Na przykład, jeśli zaczniemy od tablicy

2 5 4 9 3 4

Teraz układamy je w ukośną kolumnę:

     2
      5
       4
        9
         3
          4

Teraz wypełniamy następną przekątną. Bezwzględne różnice między kolejnymi elementami tej tablicy to:

3 1 5 6 1

To nasza kolejna przekątna.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Powtarzaj, aż piramida zostanie wypełniona:

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

Wyzwanie

Biorąc pod uwagę listę dodatnich liczb całkowitych w zakresie [0, 9], wygeneruj tę reprezentację ASCII piramidy różnic dla tej konkretnej tablicy. Gwarantowane wejście zawiera co najmniej dwa elementy. Możesz wziąć te liczby w dowolnym rozsądnym formacie. (Tablica / lista / jakkolwiek to nazwiesz, ciąg znaków, argumenty wiersza poleceń itp.) Dopuszczalne są spacje końcowe w każdej linii i do jednej nowej linii nowej.

Przetestuj 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

Jak zwykle jest to gra w golfa, więc obowiązują standardowe luki i wygrywa najkrótsza odpowiedź w bajtach!

Zainspirowany tym OEIS i tą hipotezą .

Galaretka , 16 bajtów

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

Wypróbuj online!

tło

Generowanie różnic jest dość proste. Do wprowadzenia

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

IA$Ṗп (wartość bezwzględna przyrostów, gdy występuje więcej niż jeden element) daje następującą nierówną tablicę 2D.

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

Uodwraca kolejność kolumn i Ṛkolejność wierszy, uzyskując następujące.

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

Teraz transponujemy wiersze i kolumny z”@, co powoduje, że wszystkie wiersze są wypełniane na tę samą długość przed transpozycją. Wynik jest następujący.

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

Odwrócenie wierszy daje

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

Aby przekształcić tablicę 2D w ciąg oddzielony spacjami, używamy wbudowanej siatki atom ( G). Łączy kolumny spacjami i wiersze liniami, dając następujący wynik.

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

Wszystko, co pozostało do zrobienia, to usunięcie dopełniającego znaku ḟ”@ , ustępując

        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

który jest pożądanym wyjściem.

CJam, 29 bajtów

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

Wypróbuj online!(Pierwszy i ostatni wiersz włączają pakiet testowy oddzielony od linii).

Wykorzystuje to kod obrotu i układu trójkąta z tej odpowiedzi, a sam trójkąt jest generowany z tą samą zasadą, co w tej odpowiedzi .

J, 46 42 39 36 bajtów

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

Proste wdrożenie. Generuje tabelę kolejnych różnic między każdą parą i powtarza ją kilka razy równą długości tablicy wejściowej. Następnie przemierza każdą przekątną tego stołu, tworząc rzędy trójkąta. Reszta to formatowanie wierszy w piramidę.

Stosowanie

   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

Wyjaśnienie

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

jmX-jN_Pd;N;_.t_M.uaVt

Wypróbuj online!

Python 3, 144 bajty

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

Funkcja, która pobiera dane z listy x za pomocą argumentu i wypisuje wynik na STDOUT.

Jak to działa

Program pobiera dane z listy xi inicjuje listę zagnieżdżoną, ytaką jak y[0] = x. Różnice bezwzględne dla ostatniej listy y(początkowo x) są następnie generowane i dołączane jako lista, yaż do osiągnięcia listy długości 1; na każdym etapie lista jest wstępnie wypełniona spacjami, tak aby wszystkie listy ymiały taką samą długość jak x. Kolejny,y jest transponowany, pozostawiając zawiera krotkę dla każdej linii wyjściowej, ale odwrócony. Każda krotka w transpozycji jest rozpakowywana, odwracana i drukowana, pozostawiając piramidę różnic na STDOUT.

Wypróbuj na Ideone