Напишите функцию или программу, которая выводит номер каждого типа элемента (вершина, ребро, грань и т. Д.) N-мерного гиперкуба.

Например, трехмерный куб имеет 1 ячейку (т.е. 1 3-мерный куб), 6 граней (т.е. 6 2-мерных кубов), 12 ребер (т.е. 12 2-мерных кубов) и 8 вершин (т.е. 8 0-мерных куба).

Подробнее об элементах гиперкуба можно узнать здесь

Вы также можете взглянуть на следующую последовательность OEIS .

вход

Ваш код будет принимать в качестве входных данных (через STDIN или параметр функции или подобные вещи) целое число, большее или равное 0, которое является измерением гиперкуба.

Ваш код должен теоретически работать для любого ввода> = 0, не учитывая проблемы с памятью и временем (то есть скорость и потенциальные переполнения стека не являются проблемой для вашего ответа, если вход большой). Входные данные, приведенные в качестве контрольных примеров, не будут превышать 12.

Выход

Вы выведете список всех элементов гиперкуба, начиная с элемента «самый высокий размер». Например, для куба (input = 3) вы выведете список [1,6,12,8](1 ячейка, 6 граней, 12 ребер, 8 вершин).

Формат списка в выводе является относительно бесплатным, если он выглядит как список.

Вы можете вывести результат в STDOUT или вернуть его из функции.

Контрольные примеры

Input = 0
Output = [1]

Input = 1
Output = [1,2]

Input = 3
Output = [1,6,12,8]

Input = 10
Output = [1, 20, 180, 960, 3360, 8064, 13440, 15360, 11520, 5120, 1024]

Input = 12
Output = [1, 24, 264, 1760, 7920, 25344, 59136, 101376, 126720, 112640, 67584, 24576, 4096]

счет

Это код-гольф , поэтому выигрывает самый короткий ответ в байтах.

Самау , 8 5 байт

Сохранено 3 байта благодаря Денису .

▌2\$ⁿ

Шестнадцатеричный дамп (Samau использует кодировку CP737):

dd 32 2f 24 fc

Объяснение:

▌        read a number
 2\      push the array [1 2]
   $     swap
    ⁿ    take the convolution power

Свертка двух векторов эквивалентна умножению двух полиномов . Аналогично, взятие n-й степени свертки эквивалентно взятию n-й степени полинома.

J, 13 байт

[:p.2&^;$&_.5

Вдохновленный ответом PARI / GP @ alephalpha . Попробуйте его в Интернете с J.js .

Фон

По биномиальной теореме

Таким образом, выходные данные для ввода n состоят именно из коэффициентов приведенного выше полинома.

Код

[:p.2&^;$&_.5  Monadic verb. Argument: n

        $&_.5  Yield an array of n instances of -0.5.
    2&^        Compute 2^n.
       ;       Link the results to the left and right.
               This specifies a polynomial of n roots (all -0.5)
               with leading term 2^n.  
[:p.           Convert from roots to coefficients.

MATL, 8 байт

1i:"2:X+

Вдохновленный ответом PARI / GP @ alephalpha .

Попробуйте онлайн! (использует Y+для современного дня MATL)

Как это устроено

1        % Push 1.
 i:      % Push [1 ... input].
   "     % Begin for-each loop:
    2:   %   Push [1 2].
      X+ %   Take the convolution product of the bottom-most stack item and [1 2].

MATL , 12 байт

Q:q"H@^G@Xn*

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

объяснение

         % implicit: input number "n"
Q:q      % generate array[0,1,...,n]
"        % for each element "m" from that array
  H@^    % compute 2^m
  G      % push n
  @      % push m
  Xn     % compute n choose m
  *      % multiply
         % implicit: close loop and display stack contents

Mathematica, 29 байт

CoefficientList[(1+2x)^#,x]&

Мой первый ответ Mathematica! Это чистая функция , которая использует тот же подход , как PARI / GP Alephalpha в ответ . Построим полином (1+2x)^nи получим список коэффициентов, перечисленных в порядке возрастания степени (т. Е. Константы сначала).

Пример использования:

> F := CoefficientList[(1+2x)^#,x]&`
> F[10]
{1,20,180,960,3360,8064,13440,15360,11520,5120,1024}

APL, 15 11 байт

1,(2*⍳)×⍳!⊢

Это последовательность монадических функций, которая принимает целое число справа и возвращает целочисленный массив.

Пояснение, вызов ввода n:

        ⍳!⊢  ⍝ Get n choose m for each m from 1 to n
       ×     ⍝ Multiply elementwise by
  (2*⍳)      ⍝ 2^m for m from 1 to n
1,           ⍝ Tack 1 onto the front to cover the m=0 case

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

Сохранено 4 байта благодаря Денису!

PARI / GP, 20 15 байт

n->Vec((x+2)^n)

Желе, 8 байт

0rð2*×c@

Я действительно должен прекратить писать Jelly на моем телефоне.

0r            Helper link. Input is n, inclusive range from 0 to n. Call the result r.
  ð           Start a new, dyadic link. Input is r, n.
   2*         Vectorized 2 to the power of r
     ×c@      Vectorized multiply by n nCr r. @ switches argument order.

Попробуй это здесь .

TI-BASIC, 10 байтов

3^Ansbinompdf(Ans,2/3

CJam ( 17 14 байт)

ri_3@#_2+@#\b`

Онлайн демо

Этот подход использует обычную производящую функцию (x + 2)^n. OEIS упоминает (2x + 1)^n, но этот вопрос индексирует коэффициенты в обратном порядке. Я пинаю себя за то, что не думал повернуть gf, пока не увидел обновление Alephalpha к ответу PARI / GP, которое сделало то же самое.

Интересный трюк в этом ответе заключается в использовании целочисленных степеней для операции с полиномиальной степенью при работе на базе выше любого возможного коэффициента. В общем, данный многочлен p(x), коэффициенты которого все неотрицательные целые числа меньше, чем b, p(b)является базовым bпредставлением коэффициентов (потому что отдельные одночлены не «перекрываются»). Очевидно, (x + 2)^nбудут иметь коэффициенты, которые являются положительными целыми числами и которые суммируются 3^n, поэтому каждый из них будет индивидуально меньше, чем 3^n.

ri     e# Read an integer n from stdin
_3@#   e# Push 3^n to the stack
_2+    e# Duplicate and add 2, giving a base-3^n representation of x+2
@#     e# Raise to the power of n
\b`    e# Convert into a vector of base-3^n digits and format for output

Альтернативные подходы: в 17 байтов

1a{0X$2f*+.+}ri*`

Онлайн демо

или

1a{0X$+_]:.+}ri*`

Онлайн демо

оба работают, суммируя предыдущий ряд со смещенной и удвоенной строкой (в стиле, аналогичном стандартной ручной конструкции треугольника Паскаля).

«Прямой» подход с использованием декартовых степеней (в отличие от целочисленных степеней) для операции с полиномиальными степенями имеет размер 24 байта:

2,rim*{1b_0a*2@#+}%z1fb`

где карта, как правило, достаточно сложна, чтобы использовать ее короче, %чем f:

2,rim*1fb_0af*2@f#.+z1fb`

ES6, 71 байт

n=>[...Array(n+1)].fill(n).map(b=(n,i)=>!i?1:i>n?0:b(--n,i-1)*2+b(n,i))

Простая рекурсивная формула. Каждый гиперкуб создается путем перемещения предыдущего блока 1 гиперкуба по N-му измерению. Это означает, что M-мерные объекты дублируются в начале и конце модуля, но также (M-1) -мерные объекты приобретают дополнительное измерение, превращаясь в M-мерные объекты. Другими словами, c(n, m) = c(n - 1, m) * 2 + c(n - 1, m - 1). (Фактическая отправка изменяет параметры так, что формула выводится в нужном порядке.)

Гениально, fillпозволяет mapпредоставлять правильные аргументы рекурсивной функции, экономя мне 6 байтов.

Pyth, 10 9 байтов

.<L.cQdhQ

Использует алгоритм nCr, который все используют.

05AB1E , 9 байтов

Код:

WƒNoZNc*,

Объяснение:

W          # Push input and store in Z
 ƒ         # For N in range(0, input + 1)
  No       # Compute 2**N
    ZNc    # Compute Z nCr N
       *   # Multiply
        ,  # Pop and print

Использует кодировку CP-1252.

Юлия, 31 байт

n->[2^m*binomial(n,m)for m=0:n]

Это лямбда-функция, которая принимает целое число и возвращает целочисленный массив. Чтобы вызвать его, присвойте его переменной.

Для каждого m от 0 до входа n мы подсчитываем количество ( n - m ) -мерных гиперкубов на границе родительского n -мерного гиперкуба. Используя формулу в Википедии, это просто 2 ^m * select ( n , m ). Случай m = 0 относится к самому n- кубу, поэтому вывод начинается с 1 независимо от ввода. Края заданы m = n , вершины - m = n - 1 и т. Д.

Ruby, Rev B 57 байт

->n{a=[1]+[0]*n
(n*n).downto(n){|i|a[1+j=i%n]+=2*a[j]}
a}

Предыдущий оборот каждый раз сканировал только использованную часть массива. Этот оборот просматривает весь массив на каждой итерации. Это медленнее, но экономит байты. Дальнейший байт сохраняется с помощью 1 цикла, чтобы выполнить работу 2.

Ruby, Rev A 61 байт

->n{a=[1]+[0]*n
n.times{|i|i.downto(0){|j|a[j+1]+=2*a[j]}}
a}

Начинается с точки и итеративно создает следующее измерение

В каждой итерации каждый существующий элемент увеличивается в размерности и генерирует 2 новых элемента своей исходной размерности. Например, для квадрата в горизонтальной плоскости, который вытянут вертикально, чтобы стать кубом:

1 грань становится кубом и генерирует 1 пару граней (1 сверху, 1 снизу)

4 ребра становятся гранями и генерируют 4 пары ребер (4 сверху, 4 снизу)

4 вершины становятся ребрами и генерируют 4 пары вершин (4 сверху, 4 снизу)

Неуправляемый в тестовой программе

f=->n{a=[1]+[0]*n                  #make an array with the inital point and space for other dimensions
  n.times{|i|                      #iteratively expand dimension by dimension 
    i.downto(0){|j|a[j+1]+=2*a[j]} #iterating downwards (to avoid interferences) add the 2 new elements generated by each existing element.
  }
a}                                 #return the array

p f[gets.to_i]