Escreva uma função ou programa que produza o número de cada tipo de elemento (vértice, aresta, face etc.) de um hipercubo N-dimensional.

Como exemplo, o cubo tridimensional possui 1 célula (ou seja, 1 cubo tridimensional), 6 faces (ou seja, 6 cubos bidimensionais), 12 arestas (ou seja, 12 cubos bidimensionais) e 8 vértices (ou seja, 8 dimensões 0 cubos).

Mais detalhes sobre os elementos do Hypercube podem ser encontrados aqui

Você também pode dar uma olhada na seguinte sequência OEIS .

Entrada

Seu código terá como entrada (via STDIN ou um parâmetro de função ou algo semelhante) um número inteiro maior ou igual a 0, que é a dimensão do hipercubo.

Teoricamente, seu código deve funcionar para qualquer entrada> = 0, desconsiderando problemas de memória e tempo (ou seja, velocidade e estouros de pilha em potencial não são um problema para sua resposta se a entrada for grande). As entradas fornecidas como casos de teste não serão superiores a 12.

Resultado

Você emitirá uma lista de todos os elementos do hipercubo, começando com o elemento "maior dimensão". Por exemplo, para um cubo (entrada = 3), você exibirá a lista [1,6,12,8](1 célula, 6 faces, 12 arestas, 8 vértices).

O formato da lista na saída é relativamente livre, desde que pareça uma lista.

Você pode enviar o resultado para STDOUT ou retorná-lo de uma função.

Casos de teste

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]

Pontuação

Isso é código-golfe , então a resposta mais curta em bytes vence.

Samau , 8 5 bytes

Economizou 3 bytes graças a Dennis .

▌2\$ⁿ

Despejo hexadecimal (a Samau usa a codificação CP737):

dd 32 2f 24 fc

Explicação:

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

A participação de dois vetores é equivalente à multiplicação de dois polinômios . Da mesma forma, tomar a n-ésima potência de convolução é equivalente a tomar a n-ésima potência de um polinômio.

J, 13 bytes

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

Inspirado na resposta PARI / GP de @ alephalpha . Experimente online com J.js .

fundo

Pelo teorema binomial,

Assim, a saída para a entrada n consiste precisamente nos coeficientes do polinômio acima.

Código

[: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 bytes

1i:"2:X+

Inspirado na resposta PARI / GP de @ alephalpha .

Experimente online! (usa Y+para o MATL dos dias modernos)

Como funciona

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 bytes

Q:q"H@^G@Xn*

Experimente online

Explicação

         % 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 bytes

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

Minha primeira resposta do Mathematica! Essa é uma função pura que usa a mesma abordagem da resposta PARI / GP de Alephalpha . Construímos o polinômio (1+2x)^ne obtemos a lista de coeficientes, listados em ordem de potência ascendente (ou seja, constante primeiro).

Exemplo de uso:

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

APL, 15 11 bytes

1,(2*⍳)×⍳!⊢

Este é um trem de função monádica que aceita um número inteiro à direita e retorna um array inteiro.

Explicação, chamando a entrada 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

Experimente online

Economizou 4 bytes graças a Dennis!

PARI / GP, 20 15 bytes

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

Gelatina, 8 bytes

0rð2*×c@

Eu realmente deveria parar de escrever Jelly no meu telefone.

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.

Experimente aqui .

TI-BASIC, 10 bytes

3^Ansbinompdf(Ans,2/3

CJam ( 17 14 bytes)

ri_3@#_2+@#\b`

Demonstração online

Essa abordagem usa a função geradora comum (x + 2)^n. O OEIS menciona (2x + 1)^n, mas esta questão indexa os coeficientes na ordem oposta. Estou me chutando por não pensar em reverter o FG até que vi a atualização de Alefalpha na resposta do PARI / GP, que fez o mesmo.

O truque interessante nesta resposta é usar potências inteiras para a operação de potência polinomial operando em uma base mais alta que qualquer coeficiente possível. Em geral, dado um polinômio p(x)cujos coeficientes são todos inteiros não negativos menores que b, p(b)é uma brepresentação básica dos coeficientes (porque os monômeros individuais não "se sobrepõem"). Claramente (x + 2)^nterá coeficientes que são números inteiros positivos e que somam 3^n, então cada um deles será individualmente menor que 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

Abordagens alternativas: em 17 bytes

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

Demonstração online

ou

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

Demonstração online

os dois funcionam somando a linha anterior com uma linha offset e dobrada (em um estilo semelhante à construção manual padrão do triângulo de Pascal).

Uma abordagem "direta" usando potências cartesianas (em oposição às potências inteiras) para a operação de potência polinomial, tem 24 bytes:

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

onde o mapa é incomumente complicado o suficiente para ser mais curto do %que f:

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

ES6, 71 bytes

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

Fórmula recursiva simples. Cada hipercubo é criado movendo a unidade anterior do hipercubo 1 através da enésima dimensão. Isso significa que os objetos tridimensionais M são duplicados no início e no final da unidade, mas também os objetos tridimensionais (M-1) ganham uma dimensão extra, transformando-se em objetos tridimensionais. Em outras palavras c(n, m) = c(n - 1, m) * 2 + c(n - 1, m - 1),. (O envio real reverte os parâmetros para que a fórmula saia na ordem desejada.)

Engenhosamente, fillpermite mapfornecer os argumentos corretos para a função recursiva, economizando 6 bytes.

Pitão, 10 9 bytes

.<L.cQdhQ

Usa o algoritmo nCr que todo mundo parece estar usando.

05AB1E , 9 bytes

Código:

WƒNoZNc*,

Explicação:

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

Usa a codificação CP-1252.

Julia, 31 bytes

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

Esta é uma função lambda que aceita um número inteiro e retorna uma matriz inteira. Para chamá-lo, atribua-o a uma variável.

Para cada m de 0 à entrada n , contamos o número de hipercubos ( n - m ) -dimensionais no limite do hipercubo n- dimensional pai . Usando a fórmula na Wikipedia, é simplesmente 2 ^m * escolher ( n , m ). O caso de m = 0 refere-se ao próprio cubo n , portanto a saída começa com 1, independentemente da entrada. As arestas são dadas por m = n , os vértices por m = n - 1, etc.

Ruby, Rev B 57 bytes

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

A rotação anterior varria apenas a parte usada da matriz a cada vez. Essa revisão varre toda a matriz em todas as iterações. Isso é mais lento, mas salva bytes. Um byte adicional é salvo usando 1 loop para fazer o trabalho de 2.

Ruby, Rev A 61 bytes

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

Começa com um ponto e cria iterativamente a próxima dimensão

Em cada iteração, cada elemento existente aumenta em dimensionalidade e gera 2 novos elementos de sua dimensionalidade original. Por exemplo, para um quadrado no plano horizontal que é estendido verticalmente para se tornar um cubo:

A 1 face se torna um cubo e gera 1 par de faces (1 acima, 1 abaixo)

As 4 arestas tornam-se faces e geram 4 pares de arestas (4 acima, 4 abaixo)

Os 4 vértices tornam-se arestas e geram 4 pares de vértices (4 acima, 4 abaixo)

Ungolfed in program program

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]