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

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-массив в строку, разделенную пробелами, мы используем встроенную сетку atom ( 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

Pyth, 22 байта

jmX-jN_Pd;N;_.t_M.uaVt

Попробуйте онлайн!

Python 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