Scrivi una funzione o un programma che emetta il numero di ciascun tipo di elemento (vertice, bordo, faccia, ecc.) Di un ipercubo N-dimensionale.

Ad esempio, il cubo tridimensionale ha 1 cella (ovvero 1 cubo tridimensionale), 6 facce (ovvero 6 cubi bidimensionali), 12 bordi (ovvero 12 cubi bidimensionali) e 8 vertici (ovvero 8 cubi 0 cubi).

Maggiori dettagli sugli elementi Hypercube sono disponibili qui

Puoi anche dare un'occhiata alla seguente sequenza OEIS .

Ingresso

Il tuo codice prenderà come input (tramite STDIN o un parametro di funzione o cose simili) un numero intero maggiore o uguale a 0, che è la dimensione dell'ipercubo.

Il codice deve teoricamente funzionare per qualsiasi input> = 0, ignorando i problemi di memoria e di tempo (ovvero, la velocità e i potenziali overflow dello stack non sono un problema per la tua risposta se l'input è grande). Gli input forniti come casi di test non saranno superiori a 12.

Produzione

Eseguirai un elenco di tutti gli elementi dell'ipercubo, iniziando con l'elemento "dimensione massima". Ad esempio, per un cubo (input = 3), verrà visualizzato l'elenco [1,6,12,8](1 cella, 6 facce, 12 bordi, 8 vertici).

Il formato dell'elenco nell'output è relativamente libero, purché assomigli a un elenco.

È possibile inviare il risultato a STDOUT o restituirlo da una funzione.

Casi test

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]

punteggio

Questo è code-golf , quindi vince la risposta più breve in byte.

Samau , 8 5 byte

Salvato 3 byte grazie a Dennis .

▌2\$ⁿ

Dump esadecimale (Samau utilizza la codifica CP737):

dd 32 2f 24 fc

Spiegazione:

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

Convolgere due vettori equivale a moltiplicare due polinomi . Allo stesso modo, prendere l'ennesima potenza di convoluzione equivale a prendere l'ennesima potenza di un polinomio.

J, 13 byte

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

Ispirato dalla risposta PARI / GP di @alephalpha . Provalo in rete con J.js .

sfondo

Secondo il teorema binomiale,

Pertanto, l'uscita per l'ingresso n consiste precisamente dei coefficienti del polinomio di cui sopra.

Codice

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

1i:"2:X+

Ispirato dalla risposta PARI / GP di @alephalpha .

Provalo online! (utilizza Y+per MATL dei giorni nostri)

Come funziona

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 byte

Q:q"H@^G@Xn*

Provalo online

Spiegazione

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

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

La mia prima risposta Mathematica! Questa è una funzione pura che utilizza lo stesso approccio della risposta PARI / GP di Alephalpha . Costruiamo il polinomio (1+2x)^ne otteniamo l'elenco dei coefficienti, elencati in ordine di potenza crescente (cioè prima costante).

Esempio di utilizzo:

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

APL, 15 11 byte

1,(2*⍳)×⍳!⊢

Questo è un treno di funzioni monadico che accetta un numero intero sulla destra e restituisce un array di numeri interi.

Spiegazione, chiamando l'input 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

Provalo online

Risparmiato 4 byte grazie a Dennis!

PARI / GP, 20 15 byte

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

Gelatina, 8 byte

0rð2*×c@

Dovrei davvero smettere di scrivere Jelly sul mio telefono.

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.

Provalo qui .

TI-BASIC, 10 byte

3^Ansbinompdf(Ans,2/3

CJam ( 17 14 byte)

ri_3@#_2+@#\b`

Demo online

Questo approccio utilizza la normale funzione generatrice (x + 2)^n. L'OEIS menziona (2x + 1)^n, ma questa domanda indicizza i coefficienti nell'ordine opposto. Mi sto prendendo a calci per non aver pensato di invertire la gf fino a quando non ho visto l'aggiornamento di Alephalpha alla risposta PARI / GP che ha fatto lo stesso.

Il trucco interessante in questa risposta è usare potenze intere per l'operazione di potenza polinomiale operando in una base superiore a qualsiasi possibile coefficiente. In generale, dato un polinomio i p(x)cui coefficienti sono tutti interi non negativi inferiori a b, p(b)è una brappresentazione base dei coefficienti (perché i singoli monomi non "si sovrappongono"). Chiaramente(x + 2)^n avranno coefficienti che sono numeri interi positivi e che si sommano 3^n, quindi ciascuno di essi sarà individualmente inferiore a 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

Approcci alternativi: a 17 byte

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

Demo online

o

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

Demo online

entrambi funzionano sommando la riga precedente con una riga offset e raddoppiata (in uno stile simile alla costruzione manuale standard del triangolo di Pascal).

Un approccio "diretto" che utilizza poteri cartesiani (al contrario di poteri interi) per l'operazione di potere polinomiale, arriva a 24 byte:

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

dove la mappa è, insolitamente, abbastanza complicata da essere più breve da usare %di f:

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

ES6, 71 byte

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

Semplice formula ricorsiva. Ogni ipercubo viene creato spostando l'unità ipercubo 1 precedente nell'ennesima dimensione. Ciò significa che gli oggetti M-dimensionali sono duplicati all'inizio e alla fine dell'unità, ma anche gli oggetti tridimensionali (M-1) acquisiscono una dimensione aggiuntiva, trasformandosi in oggetti M-dimensionali. In altre parole,c(n, m) = c(n - 1, m) * 2 + c(n - 1, m - 1) . (L'invio effettivo inverte i parametri in modo che la formula venga emessa nell'ordine desiderato.)

Ingegnosamente, fillpermette mapdi fornire gli argomenti corretti alla funzione ricorsiva, salvandomi 6 byte.

Pyth, 10 9 byte

.<L.cQdhQ

Utilizza l'algoritmo nCr che tutti sembrano utilizzare.

05AB1E , 9 byte

Codice:

WƒNoZNc*,

Spiegazione:

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

Utilizza la codifica CP-1252.

Julia, 31 byte

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

Questa è una funzione lambda che accetta un numero intero e restituisce un array di numeri interi. Per chiamarlo, assegnarlo a una variabile.

Per ogni m da 0 all'ingresso n , contiamo il numero di ipercubi tridimensionali ( n - m ) sul limite dell'ipercubo n- dimensionale genitore . Usando la formula su Wikipedia, è semplicemente 2 ^m * scegliere ( n , m ). Il caso di m = 0 si riferisce al cubo n stesso, quindi l'output inizia con 1 indipendentemente dall'input. I bordi sono dati da m = n , i vertici da m = n - 1, ecc.

Rubino, Rev B 57 byte

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

Il rev precedente ha solo scansionato la parte usata dell'array ogni volta. Questo rev analizza l'intero array su ogni iterazione. Questo è più lento, ma consente di risparmiare byte. Un ulteriore byte viene salvato usando 1 loop per fare il lavoro di 2.

Rubino, Rev. A 61 byte

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

Inizia con un punto e crea iterativamente la dimensione successiva

In ogni iterazione, ogni elemento esistente aumenta nella dimensionalità e genera 2 nuovi elementi della sua dimensionalità originale. Ad esempio, per un quadrato nel piano orizzontale che viene esteso verticalmente per diventare un cubo:

La 1 faccia diventa un cubo e genera 1 coppia di facce (1 sopra, 1 sotto)

I 4 bordi diventano facce e generano 4 coppie di bordi (4 sopra, 4 sotto)

I 4 vertici diventano bordi e generano 4 coppie di vertici (4 sopra, 4 sotto)

Non registrato nel programma di test

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]