Một kim tự tháp khác biệt là một kim tự tháp trong đó mỗi đường chéo mới là giá trị tuyệt đối của sự khác biệt giữa các yếu tố của đường chéo cuối cùng. Ví dụ, nếu chúng ta bắt đầu với mảng

2 5 4 9 3 4

Bây giờ, chúng tôi sắp xếp những thứ này trong một cột chéo:

     2
      5
       4
        9
         3
          4

Bây giờ, chúng tôi điền vào đường chéo tiếp theo. Sự khác biệt tuyệt đối giữa các yếu tố liên tiếp của mảng này là:

3 1 5 6 1

Vì vậy, đó là đường chéo tiếp theo của chúng tôi.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Lặp lại cho đến khi kim tự tháp được điền vào:

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

Các thách thức

Đưa ra một danh sách các số nguyên dương trong phạm vi [0, 9], tạo biểu diễn nghệ thuật ASCII này của kim tự tháp khác biệt cho mảng cụ thể đó. Đầu vào được đảm bảo chứa ít nhất hai yếu tố. Bạn có thể lấy những con số này trong bất kỳ định dạng hợp lý. (Mảng / danh sách / bất cứ thứ gì bạn gọi nó, một chuỗi, đối số dòng lệnh, v.v.) Cho phép không gian lưu trữ trên mỗi dòng và tối đa một dòng mới theo dõi.

Kiểm tra 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

Như thường lệ, đây là môn đánh gôn, vì vậy các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất bằng byte sẽ thắng!

Lấy cảm hứng từ OEIS này và phỏng đoán này .

Thạch , 16 byte

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

Hãy thử trực tuyến!

Lý lịch

Tạo ra sự khác biệt là khá đơn giản. Đối với đầu vào

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

IA$Ṗп (giá trị tuyệt đối của số gia trong khi có nhiều hơn một phần tử) mang lại mảng 2D rách rưới sau đây.

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

Uđảo ngược thứ tự của các cột và Ṛthứ tự của các hàng, thu được các giá trị sau.

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

Bây giờ, chúng transpose hàng và cột với z”@, mà miếng đệm tất cả các hàng cùng độ dài trước transposing. Kết quả là như sau.

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

Đảo ngược các hàng cho

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

Để biến mảng 2D thành một chuỗi phân tách khoảng trắng, chúng tôi sử dụng nguyên tử lưới tích hợp ( G). Nó tham gia các cột theo khoảng trắng và hàng theo nguồn cấp dữ liệu, mang lại kết quả sau.

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

Tất cả những gì còn lại phải làm là loại bỏ ký tự đệm ḟ”@, mang lại

        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

đó là đầu ra mong muốn.

CJam, 29 byte

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

Hãy thử trực tuyến! (Dòng đầu tiên và dòng cuối cùng cho phép bộ kiểm tra được phân tách bằng nguồn cấp.)

Điều này sử dụng mã xoay và bố trí tam giác từ câu trả lời này và chính tam giác được tạo ra với cùng một nguyên tắc như trong câu trả lời này .

J, 46 42 39 36 byte

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

Một thực hiện thẳng về phía trước. Tạo một bảng các khác biệt liên tiếp giữa mỗi cặp và lặp lại nó một số lần bằng với độ dài của mảng đầu vào. Sau đó đi qua từng đường chéo của bảng đó để tạo thành các hàng của tam giác. Phần còn lại là định dạng các hàng thành một kim tự tháp.

Sử dụng

   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

Giải trình

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

Bình thường, 22 byte

jmX-jN_Pd;N;_.t_M.uaVt

Hãy thử trực tuyến!

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

Hàm lấy đầu vào của danh sách x thông qua đối số và in kết quả sang STDOUT.

Làm thế nào nó hoạt động

Chương trình lấy đầu vào của một danh sách xvà khởi tạo một danh sách lồng nhau ysao cho y[0] = x. Sự khác biệt tuyệt đối cho danh sách cuối cùng trong y(ban đầu x) sau đó được tạo ra và được thêm vào như một danh sách cho yđến khi 1đạt được danh sách độ dài ; ở mỗi giai đoạn, danh sách được đệm trước bằng khoảng trắng sao cho tất cả các danh sách ycó cùng độ dài với x. Tiếp theo, yđược hoán vị, để lại nó chứa một tuple cho mỗi dòng đầu ra, nhưng đảo ngược. Mỗi bộ trong chuyển vị được giải nén, đảo ngược và in, để lại hình chóp khác biệt trên STDOUT.

Hãy thử nó trên Ideone