N 차원 하이퍼 큐브의 각 요소 유형 (정점, 모서리,면 등)의 수를 출력하는 함수 또는 프로그램을 작성하십시오.

예로서, 3 차원 큐브는 1 개의 셀 (즉, 1 3 차원 큐브), 6 개의면 (즉, 6 개의 2 차원 큐브), 12 개의 에지 (즉, 12 개의 2 차원 큐브) 및 8 개의 정점 (즉, 8 0 차원)을 갖는다 큐브).

하이퍼 큐브 요소에 대한 자세한 내용은 여기를 참조하십시오.

다음 OEIS 시퀀스를 살펴볼 수도 있습니다 .

입력

코드는 (STDIN 또는 함수 매개 변수 또는 이와 유사한 것들을 통해) 0보다 크거나 같은 정수로 입력 될 것이며, 이는 하이퍼 큐브의 차원입니다.

코드는 메모리 및 시간 문제를 무시하고 이론적으로 모든 입력> = 0에 대해 작동해야합니다 (즉, 입력이 큰 경우 속도 및 잠재적 스택 오버플로는 대답에 문제가되지 않습니다). 테스트 사례로 제공된 입력은 12를 초과하지 않습니다.

산출

"가장 높은 치수"요소로 시작하여 하이퍼 큐브의 모든 요소 목록을 출력합니다. 예를 들어 큐브 (입력 = 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]

채점

이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

사마 우 , 8 5 바이트

Dennis 덕분에 3 바이트를 절약했습니다 .

▌2\$ⁿ

16 진 덤프 (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

@alephalpha의 PARI / GP 답변에서 영감을 얻었습니다. . 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+

@alephalpha의 PARI / GP 답변에서 영감을 얻었습니다. .

온라인으로 사용해보십시오! ( 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

매스 매 티카, 29 바이트

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

나의 첫번째 Mathematica 답변! 이것은 Alephalpha의 PARI / GP answer 와 동일한 접근 방식을 사용하는 순수한 함수입니다 . 다항식을 만듭니다(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

온라인으로 사용해보십시오

Dennis 덕분에 4 바이트를 절약했습니다!

PARI / GP, 20 15 바이트

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

젤리, 8 바이트

0rð2*×c@

전화로 젤리 쓰기를 정말로 중단해야합니다.

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 하지만이 질문은 계수를 반대 순서로 색인화합니다. 나는 Alephalpha가 PARI / GP 답변에 대한 업데이트를 볼 때까지 gf를 뒤집지 않으려 고 생각하고 있습니다.

이 답변의 흥미로운 요령은 가능한 모든 계수보다 높은 기저에서 작동하여 다항식 연산에 정수 전력을 사용하는 것입니다. 일반적으로, 주어진 다항식 p(x)계수들이 이하 모든 음이 아닌 정수이다 b, p(b)베이스 - 인 b계수의 표현 (개별 monomials 안 "오버랩"않기 때문에). 분명히(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]

정수를 받아들이고 정수 배열을 반환하는 람다 함수입니다. 호출하려면 변수에 지정하십시오.

0에서 입력 n 까지의 각 m 에 대해 부모 n 차원 하이퍼 큐브 의 경계에서 ( n - m ) 차원 하이퍼 큐브 의 수를 계산합니다 . Wikipedia의 공식을 사용하면 간단히 ^2m * choose ( n , m )입니다. m = 0 의 경우는 n- 큐브 자체를 나타내므로 입력에 관계없이 출력은 1로 시작합니다. 모서리는 m = n , 꼭지점은 m = n -1 등으로 지정됩니다.

루비, 레브 B 57 바이트

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

이전 rev는 매번 어레이의 사용 된 부분을 통해서만 스캔했습니다. 이 rev는 모든 반복에서 전체 배열을 스캔합니다. 속도는 느리지 만 바이트를 절약합니다. 1 바이트를 사용하여 2의 작업을 수행하면 추가 바이트가 저장됩니다.

루비, 레브 A 61 바이트

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

점으로 시작하여 다음 차원을 반복적으로 만듭니다.

각 반복에서 기존의 각 요소는 차원이 증가하고 원래 차원의 2 개의 새 요소를 생성합니다. 예를 들어, 수평면의 정사각형이 수직으로 확장되어 큐브가되는 경우 :

한면이 정육면체가되고 한 쌍의면을 생성합니다 (위의 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]