N boyutlu bir hiper küpün her bir öğe türünün (tepe noktası, kenar, yüz vb.) Sayısını çıkaran bir işlev veya program yazın.

Örnek olarak, 3 boyutlu küp 1 hücreye (yani 1 3 boyutlu küp), 6 yüze (yani 6 2 boyutlu küp), 12 kenara (yani 12 2 boyutlu küp) ve 8 köşeye (yani 8 0 boyutlu) sahiptir küpler).

Hypercube öğeleri hakkında daha fazla bilgiyi burada bulabilirsiniz

Aşağıdaki OEIS dizisine de göz atabilirsiniz .

Giriş

Kodunuz hiper küpün boyutu olan 0'a eşit veya daha büyük bir tamsayı girdi olarak (STDIN veya bir işlev parametresi veya benzeri şeyler ile) alır.

Kodunuz, bellek ve zaman sorunlarını göz ardı ederek teorik olarak herhangi bir giriş> = 0 için çalışmalıdır (yani, giriş büyükse hız ve potansiyel yığın taşmaları cevabınız için bir sorun değildir). Test senaryoları olarak verilen girdiler 12'nin üzerinde olmayacaktır.

Çıktı

"En yüksek boyut" öğesinden başlayarak hiper küpün tüm öğelerinin bir listesini çıkarırsınız. Örneğin, bir küp için (giriş = 3) listenin çıktısını alırsınız [1,6,12,8](1 hücre, 6 yüz, 12 kenar, 8 köşe).

Çıktıdaki listenin biçimi, liste gibi göründüğü sürece nispeten ücretsizdir.

Sonucu STDOUT'a gönderebilir veya bir işlevden döndürebilirsiniz.

Test senaryoları

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]

puanlama

Bu kod golf , bu yüzden bayttaki en kısa cevap kazanır.

Samau , 8 5 bayt

Dennis sayesinde 3 bayt tasarruf etti .

▌2\$ⁿ

Hex dökümü (Samau, CP737 kodlaması kullanır):

dd 32 2f 24 fc

Açıklama:

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

İki vektörün birleştirilmesi, iki polinomun çoğalmasına eşdeğerdir . Benzer şekilde, n'inci kıvrım gücünü almak bir polinomun n'inci gücünü almakla eşdeğerdir.

J, 13 bayt

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

Esinlenerek @ alephalpha en PARI / GP cevap . J.js ile çevrimiçi deneyin .

Arka fon

Binom teoremi ile,

Böylece, girdi n için çıktı tam olarak yukarıdaki polinomun katsayılarından oluşur.

kod

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

1i:"2:X+

Esinlenerek @ alephalpha en PARI / GP cevap .

Çevrimiçi deneyin! ( Y+günümüzdeki MATL için kullanılır)

Nasıl çalışır

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 bayt

Q:q"H@^G@Xn*

Çevrimiçi deneyin

açıklama

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

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

İlk Mathematica cevabım! Bu, Alephalpha'nın PARI / GP cevabı ile aynı yaklaşımı kullanan saf bir fonksiyondur . Polinomu inşa ediyoruz (1+2x)^nve artan güç sırasına göre listelenen katsayıların listesini alıyoruz (yani önce sabit).

Örnek kullanım:

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

APL, 15 11 bayt

1,(2*⍳)×⍳!⊢

Bu, sağdaki bir tamsayıyı kabul eden ve bir tamsayı dizisi döndüren monadik bir işlev dizisidir.

Giriş, çağrı çağırma 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

Çevrimiçi deneyin

Dennis sayesinde 4 bayt tasarruf etti!

PARI / GP, 20 15 bayt

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

Jöle, 8 bayt

0rð2*×c@

Telefonumda Jelly yazmayı gerçekten bırakmalıyım.

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.

Burada deneyin .

TI-BASIC, 10 bayt

3^Ansbinompdf(Ans,2/3

CJam ( 17 14 bayt)

ri_3@#_2+@#\b`

Çevrimiçi demo

Bu yaklaşım, sıradan üretici işlevi kullanır (x + 2)^n. OEIS'den bahseder (2x + 1)^n, ancak bu soru katsayıları ters sırada endeksler. Alephalpha'nın aynı şeyi yapan PARI / GP cevabı güncellemesini görene kadar gf'yi tersine çevirmeyi düşünmediğim için kendimi tekmeliyorum.

Bu cevaptaki ilginç numara, olası katsayılardan daha yüksek bir bazda çalışarak polinom güç operasyonu için tamsayı güçler kullanmaktır. Genel olarak, bir çok terimli verilen p(x)katsayıları daha az olmayan tüm negatif tamsayı olan b, p(b)bir baz-olduğu bkatsayılarının gösterimi (bireysel monomials değil "örtüşme", çünkü). Açıkça (x + 2)^npozitif tamsayılar ve toplamları olan katsayılara sahip olacağından 3^n, her biri ayrı ayrı daha küçük olacaktır 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

Alternatif yaklaşımlar: 17 baytta

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

Çevrimiçi demo

veya

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

Çevrimiçi demo

her ikisi de bir önceki satırı ofset ve iki katına çıkaran bir satırla toplayarak çalışır (Pascal üçgeninin standart manuel yapısına benzer bir tarzda).

Polinom güç operasyonu için Kartezyen güçleri (tamsayı güçlerin aksine) kullanan "doğrudan" bir yaklaşım 24 baytta gelir:

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

haritanın alışılmadık şekilde, kullanımdan %daha kısa olacak kadar karmaşık olduğu durumlarda f:

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

ES6, 71 bayt

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

Basit özyinelemeli formül. Her hiper küp, önceki hiper küp 1 birimini Nth boyutuna taşıyarak oluşturulur. Bu, M-boyutlu nesnelerin ünitenin başlangıcında ve sonunda kopyalandığı, ancak (M-1)-boyutlu nesnelerin M-boyutlu nesnelere dönüşerek ekstra bir boyut kazandığı anlamına gelir. Başka bir deyişle c(n, m) = c(n - 1, m) * 2 + c(n - 1, m - 1),. (Gerçek gönderim, formülleri istenen sırada çıkacak şekilde parametreleri tersine çevirir.)

Ustaca, fillizin verir mapbana 6 bayt tasarruf özyinelemeli işleve doğru argümanlar sunmak.

Pyth, 10 9 bayt

.<L.cQdhQ

Herkesin kullandığı nCr algoritmasını kullanır.

05AB1E , 9 bayt

Kod:

WƒNoZNc*,

Açıklama:

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 kodlamasını kullanır.

Julia, 31 bayt

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

Bu, bir tamsayıyı kabul eden ve bir tam sayı dizisi döndüren lambda işlevidir. Bunu çağırmak için bir değişkene atayın.

0'dan n girişine kadar olan her bir m için , ana n -boyutlu hiperküpün sınırındaki ( n - m ) boyutlu hiper küpleri sayıyoruz. Wikipedia'daki formülü kullanarak, sadece 2 ^m * select ( n , m ). Vaka m = 0 anlamına gelir , n çıkış, giriş 1 ile başlar, böylece, kendisi -cube. Kenarlar m = n , köşeler m = n - 1 vb. İle verilir .

Ruby, Rev B 57 bayt

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

Önceki devir, her seferinde dizinin sadece kullanılmış kısmı üzerinden taranmıştır. Bu devir her yinelemede tüm diziyi tarar. Bu daha yavaştır, ancak bayt tasarrufu sağlar. 2 işini yapmak için 1 döngü kullanılarak başka bir bayt kaydedilir.

Ruby, Rev A 61 bayt

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

Bir nokta ile başlar ve yineleyici olarak bir sonraki boyutu oluşturur

Her bir yinelemede, mevcut her bir unsur boyutsallıkta artar ve orijinal boyutluluğunda 2 yeni unsur üretir. Örneğin, yatay düzlemde küp haline gelecek şekilde dikey olarak uzatılmış bir kare için:

1 yüz bir küp haline gelir ve 1 çift yüz oluşturur (1 yukarıda, 1 aşağıda)

4 kenar yüz olur ve 4 çift kenar oluşturur (4 yukarıda, 4 aşağıda)

4 köşe kenar haline gelir ve 4 çift köşe oluşturur (yukarıda 4, aşağıda 4)

Test programında yönlendirilmemiş

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]