Viết hàm hoặc chương trình xuất số lượng của từng loại phần tử (đỉnh, cạnh, mặt, v.v.) của một hypercube N-chiều.

Ví dụ, khối 3 chiều có 1 ô (tức là 1 khối 3 chiều), 6 mặt (tức là 6 khối 2 chiều), 12 cạnh (tức là 12 khối 2 chiều) và 8 đỉnh (tức là 8 0 chiều khối).

Thông tin chi tiết về các yếu tố Hypercube có thể được tìm thấy ở đây

Bạn cũng có thể xem qua trình tự OEIS sau đây .

Đầu vào

Mã của bạn sẽ lấy làm đầu vào (thông qua STDIN hoặc tham số hàm hoặc những thứ tương tự) một số nguyên lớn hơn hoặc bằng 0, đó là thứ nguyên của hypercube.

Về mặt lý thuyết, mã của bạn phải hoạt động cho mọi đầu vào> = 0, không quan tâm đến các vấn đề về bộ nhớ và thời gian (nghĩa là tốc độ và khả năng tràn ngăn xếp không phải là vấn đề đối với câu trả lời của bạn nếu đầu vào lớn). Đầu vào được đưa ra như trường hợp thử nghiệm sẽ không được trên 12.

Đầu ra

Bạn sẽ đưa ra một danh sách tất cả các yếu tố của hypercube, bắt đầu với yếu tố "chiều cao nhất". Ví dụ: đối với khối lập phương (input = 3), bạn sẽ xuất danh sách [1,6,12,8](1 ô, 6 mặt, 12 cạnh, 8 đỉnh).

Định dạng của danh sách trong đầu ra là tương đối miễn phí, miễn là nó trông giống như một danh sách.

Bạn có thể xuất kết quả thành STDOUT hoặc trả về từ hàm.

Các trường hợp thử nghiệm

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]

Chấm điểm

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng.

Samau , 8 5 byte

Đã lưu 3 byte nhờ Dennis .

▌2\$ⁿ

Hex dump (Samau sử dụng mã hóa CP737):

dd 32 2f 24 fc

Giải trình:

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

Kết hợp hai vectơ tương đương với nhân hai đa thức . Tương tự, lấy công suất chập thứ n tương đương với lấy công suất thứ n của đa thức.

J, 13 byte

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

Lấy cảm hứng từ câu trả lời PARI / GP của @ alephalpha . Dùng thử trực tuyến với J.js .

Lý lịch

Theo định lý nhị thức,

Do đó, đầu ra cho đầu vào n bao gồm chính xác các hệ số của đa thức trên.

Mã

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

Lấy cảm hứng từ câu trả lời PARI / GP của @ alephalpha .

Hãy thử trực tuyến! (sử dụng Y+cho MATL hiện đại)

Làm thế nào nó hoạt động

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*

Dùng thử trực tuyến

Giải trình

         % 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

Toán học, 29 byte

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

Câu trả lời đầu tiên của tôi! Đây là một hàm thuần túy sử dụng cách tiếp cận tương tự như câu trả lời PARI / GP của Alephalpha . Chúng tôi xây dựng đa thức(1+2x)^n và lấy danh sách các hệ số, được liệt kê theo thứ tự công suất tăng dần (tức là hằng số đầu tiên).

Ví dụ sử dụng:

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

APL, 15 11 byte

1,(2*⍳)×⍳!⊢

Đây là một hàm hàm đơn nguyên chấp nhận một số nguyên ở bên phải và trả về một mảng số nguyên.

Giải thích, gọi đầu vào 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

Dùng thử trực tuyến

Đã lưu 4 byte nhờ Dennis!

PARI / GP, 20 15 byte

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

Thạch, 8 byte

0rð2*×c@

Tôi thực sự nên ngừng viết Jelly trên điện thoại của tôi.

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.

Hãy thử nó ở đây .

TI-BASIC, 10 byte

3^Ansbinompdf(Ans,2/3

CJam ( 17 14 byte)

ri_3@#_2+@#\b`

Bản demo trực tuyến

Cách tiếp cận này sử dụng chức năng tạo thông thường (x + 2)^n. OEIS đề cập (2x + 1)^n, nhưng câu hỏi này chỉ số các hệ số theo thứ tự ngược lại. Tôi tự đá mình vì đã không nghĩ sẽ đảo ngược gf cho đến khi tôi thấy bản cập nhật của Alephalpha cho câu trả lời PARI / GP cũng làm như vậy.

Thủ thuật thú vị trong câu trả lời này là sử dụng các số nguyên cho hoạt động của đa thức bằng cách vận hành trong một cơ sở cao hơn bất kỳ hệ số nào có thể. Nói chung, với một đa thức p(x)có hệ số đều là các số nguyên không âm nhỏ hơn b, p(b)là một bđại diện cơ bản của các hệ số (vì các đơn thức riêng lẻ không "trùng nhau"). Rõ ràng (x + 2)^nsẽ có các hệ số là số nguyên dương và tổng bằng 3^n, vì vậy mỗi hệ số sẽ nhỏ hơ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

Cách tiếp cận khác: ở mức 17 byte

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

Bản demo trực tuyến

hoặc là

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

Bản demo trực tuyến

cả hai đều hoạt động bằng cách tính tổng hàng trước với hàng bù và nhân đôi (theo kiểu tương tự với cấu trúc thủ công tiêu chuẩn của tam giác Pascal).

Một cách tiếp cận "trực tiếp" bằng cách sử dụng các lũy thừa của Cartesian (trái ngược với các lũy thừa nguyên) cho hoạt động của đa thức, có đến 24 byte:

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

Bản đồ ở đâu, bất thường, đủ phức tạp để sử dụng nó ngắn %hơn 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))

Công thức đệ quy đơn giản. Mỗi hypercube được tạo ra bằng cách di chuyển đơn vị hypercube 1 trước đó thông qua kích thước thứ N. Điều này có nghĩa là các đối tượng chiều M được nhân đôi ở đầu và cuối đơn vị, nhưng các đối tượng hai chiều (M-1) có được một chiều phụ, biến thành các đối tượng chiều M. Nói cách khác , c(n, m) = c(n - 1, m) * 2 + c(n - 1, m - 1). (Đệ trình thực tế đảo ngược các tham số để công thức xuất ra theo thứ tự mong muốn.)

Khéo léo, fillcho phép mapcung cấp các đối số chính xác cho hàm đệ quy, tiết kiệm cho tôi 6 byte.

Bình thường, 10 9 byte

.<L.cQdhQ

Sử dụng thuật toán nCr mà mọi người dường như đang sử dụng.

05AB1E , 9 byte

Mã số:

WƒNoZNc*,

Giải trình:

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

Sử dụng mã hóa CP-1252.

Julia, 31 byte

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

Đây là hàm lambda chấp nhận một số nguyên và trả về một mảng số nguyên. Để gọi nó, gán nó cho một biến.

Đối với mỗi m từ 0 đến n đầu vào , chúng ta đếm số lượng hypercubes chiều ( n - m ) trên ranh giới của hypercube n -dimensional cha mẹ . Sử dụng công thức trên Wikipedia, chỉ cần 2 ^m * select ( n , m ). Trường hợp m = 0 đề cập đến chính n -cube, vì vậy đầu ra bắt đầu bằng 1 bất kể đầu vào. Các cạnh được cho bởi m = n , các đỉnh bởi m = n - 1, v.v.

Ruby, Rev B 57 byte

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

Rev lần trước chỉ quét qua phần được sử dụng của mảng mỗi lần. Rev này quét qua toàn bộ mảng trên mỗi lần lặp. Điều này chậm hơn, nhưng nó tiết kiệm byte. Một byte nữa được lưu bằng cách sử dụng 1 vòng lặp để thực hiện công việc của 2.

Ruby, Rev A 61 byte

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

Bắt đầu với một điểm và lặp đi lặp lại tạo ra chiều tiếp theo

Trong mỗi lần lặp, mỗi phần tử hiện có tăng theo chiều và tạo ra 2 phần tử mới về chiều của nó. Ví dụ: đối với hình vuông trong mặt phẳng nằm ngang được mở rộng theo chiều dọc để trở thành khối lập phương:

Mặt 1 trở thành khối lập phương và tạo 1 cặp mặt (1 ở trên, 1 dưới)

4 cạnh trở thành các mặt và tạo ra 4 cặp cạnh (4 trên, 4 dưới)

4 đỉnh trở thành cạnh và tạo ra 4 cặp đỉnh (4 trên, 4 dưới)

Ungolfed trong chương trình thử nghiệm

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]