Різнична піраміда - це піраміда, де кожна нова діагональ - це абсолютне значення відмінностей між елементами останньої діагоналі. Наприклад, якщо ми почнемо з масиву

2 5 4 9 3 4

Тепер ми розташовуємо їх у діагональній колонці:

     2
      5
       4
        9
         3
          4

Тепер заповнюємо наступну діагональ. Абсолютні відмінності між послідовними елементами цього масиву:

3 1 5 6 1

Отже, це наша наступна діагональ.

     2
    3 5
     1 4
      5 9
       6 3
        1 4

Повторіть, доки піраміда не заповниться:

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

Змагання

Подаючи список позитивних цілих чисел у діапазоні [0, 9], створіть це ASCII-мистецтво подання різницької піраміди для конкретного масиву. Вхід гарантовано містить щонайменше два елементи. Ви можете приймати ці номери в будь-якому розумному форматі. (Масив / список / як би ви його не називали, рядок, аргументи командного рядка та ін.) Дозволені пробіли у кожному рядку та до одного останнього нового рядка.

Тест 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

Як завжди, це код-гольф, тому застосовуються стандартні лазівки, і найкоротша відповідь у байтах виграє!

Натхненний цим OEIS і цією гіпотезою .

Желе , 16 байт

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

Спробуйте в Інтернеті!

Фон

Генерування відмінностей є досить простим. Для введення

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

IA$Ṗп (абсолютне значення приростів при наявності більш ніж одного елемента) дає наступний нерівний 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]

Uповертає порядок стовпців і Ṛпорядок рядків, отримуючи наступне.

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

Тепер ми транспозируємо рядки та стовпці, за допомогою z”@яких прокладаємо всі рядки на однакову довжину, перш ніж переносити. Результат такий.

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

Повернення рядків дає

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

Щоб перетворити 2D масив у розділену пробілом пробіл, ми використовуємо вбудований атом сітки ( G). Він з'єднує стовпці пробілами та рядками за допомогою рядків каналів, даючи такий результат.

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

Все, що залишилося зробити, - це видалити персонаж з підкладки ḟ”@, поступаючись

        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

що є бажаним виходом.

CJam, 29 байт

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

Спробуйте в Інтернеті! (Перший і останній рядки включають тестовий набір, відокремлений виведенням ліній.)

Для цього використовується код обертання трикутника та компонування з цієї відповіді, а сам трикутник генерується за тим же принципом, що і у цій відповіді .

J, 46 42 39 36 байт

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

Безпосередня реалізація. Створює таблицю послідовних різниць між кожною парою і повторює її кілька разів, рівну довжині вхідного масиву. Потім проходить кожну діагональ цієї таблиці, щоб утворити рядки трикутника. Решта - це форматування рядків у піраміду.

Використання

   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

Пояснення

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

Піт, 22 байти

jmX-jN_Pd;N;_.t_M.uaVt

Спробуйте в Інтернеті!

Пітон 3, 144 байти

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

Функція, яка приймає введення списку xчерез аргумент і друкує результат на STDOUT.

Як це працює

Програма приймає введення списку xта ініціалізує вкладений список yтакий y[0] = x. Абсолютні різниці для останнього списку в y(спочатку x) потім генеруються і додаються до списку до yтих пір, поки не 1буде досягнуто список довжини ; на кожному етапі список попередньо залитий пробілами, щоб усі списки yмали однакову довжину x. Далі yтранспонірується, залишаючи його, що містить кортеж для кожного вихідного рядка, але зворотним. Кожен кортеж транспонування розпаковується, перевертається та друкується, залишаючи піраміду різниці на STDOUT.

Спробуйте це на Ideone