비디오 게임 트랜지스터 는 매우 흥미로운 능력 시스템을 갖추고 있습니다. 16 개의 다른 슬롯에서 사용할 수있는 16 개의 "기능"을 수집합니다. 흥미로운 점은 3 가지 유형의 슬롯이 있으며 사용하는 슬롯에 따라 모든 기능이 다르게 작동한다는 것입니다.

• 있다 4 개 수동 슬롯 .
• 있다 4 개 활성 슬롯 .
• 각 활성 슬롯 에는 2 개의 업그레이드 슬롯이 있습니다.

우리는 얼마나 많은 다른 기술을 제공하는지 알고 싶습니다.

그러나 일부 조합은 동일합니다. 특히, 각 슬롯 그룹 내에서 기능의 특정 위치는 중요하지 않습니다. 반면에, 업그레이드 슬롯에있는 기능의 효과는 않는 부모 활성 슬롯에 사용되는 특정 기능에 따라 달라집니다.

따라서 16 진수를 사용하여 함수를 나타내면 다음 조합은 모두 동일합니다.

Passive Slots:    0     1     2     3
Active Slots:     4     5     6     7
Upgrade Slots:   8 9   A B   C D   E F

Passive Slots:    2     0     1     3    # Permutation of passive slots.
Active Slots:     4     5     6     7
Upgrade Slots:   8 9   A B   C D   E F

Passive Slots:    0     1     2     3
Active Slots:     5     6     4     7    # Permutation of active slots together
Upgrade Slots:   A B   C D   8 9   E F   # with their upgrade slots.

Passive Slots:    0     1     2     3
Active Slots:     4     5     6     7
Upgrade Slots:   8 9   B A   C D   F E   # Permutation within upgrade slots.

이러한 재배치의 조합뿐만 아니라. 세 번째 경우에는 업그레이드 슬롯이 활성 슬롯과 함께 교환되어 동일한 전체 효과를 유지합니다.

한편, 다음 조합은 위의 세트와 모두 다릅니다.

Passive Slots:    4     5     6     7    # Passive slots swapped
Active Slots:     0     1     2     3    # with active slots.
Upgrade Slots:   8 9   A B   C D   E F

Passive Slots:    0     1     2     3
Active Slots:     5     4     6     7    # Permutation of active slots without
Upgrade Slots:   8 9   A B   C D   E F   # changing upgrade slots.

Passive Slots:    0     1     2     3
Active Slots:     4     5     6     7
Upgrade Slots:   8 A   9 B   C D   E F   # Permutation between different upgrade slots.

모든 기능이 사용된다고 가정하면 2,270,268,000 개의 가능한 (기능적으로 구별되는) 조합을 제공하는 내 카운트로는.

처리 할 기능이 16 개 미만인 경우 일부 슬롯이 비어 있습니다. 그러나 상위 활성 슬롯이 비어 있으면 업그레이드 슬롯에 기능을 배치 할 수 없습니다.

도전

보유하고있는 기능 수에 따라 가능한 구성 수를 결정해야합니다. 또한, 사소한 하드 코딩 솔루션을 방지하기 위해 슬롯 수를 가변적으로 지정하여 문제를 약간 일반화합니다.

두 개의 양의 정수를 주어진 프로그램이나 함수를 작성 M ≥ 1하고 1 ≤ N ≤ 4M정확하게 가정 할 수있다 (기능상 구별) 스킬 세트 수, 결정 N의 가능한 많은로 채우기 위해 사용되는 다른 기능을 M, 수동 M활성 및 2M슬롯 업그레이드.

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받고 STDOUT (또는 가장 가까운 대안), 함수 리턴 값 또는 함수 (out) 매개 변수를 통해 결과를 출력하는 프로그램 또는 함수를 작성할 수 있습니다.

코드는 M = 8합리적인 데스크톱 시스템에서 1 분 이내에 포함하여 모든 입력을 처리 할 수 ​​있어야합니다 . 이것에는 약간의 여유가 있지만 무차별 대입 솔루션을 배제해야합니다. 원칙적으로 이러한 입력을 1 초 이내에 해결하는 것은 문제가되지 않습니다.

이것은 코드 골프이며, 가장 짧은 대답 (바이트)이 이깁니다.

테스트 사례

각 테스트 케이스는 형식 M N => Result입니다.

1 1 => 2
1 2 => 4
1 3 => 9
1 4 => 12
2 1 => 2
2 2 => 6
2 3 => 21
2 4 => 78
2 5 => 270
2 6 => 810
2 7 => 1890
2 8 => 2520
3 1 => 2
3 2 => 6
3 3 => 23
3 4 => 98
3 5 => 460
3 6 => 2210
3 7 => 10290
3 8 => 44520
3 9 => 168840
3 10 => 529200
3 11 => 1247400
3 12 => 1663200
4 1 => 2
4 2 => 6
4 3 => 23
4 4 => 100
4 5 => 490
4 6 => 2630
4 7 => 14875
4 8 => 86030
4 9 => 490140
4 10 => 2652300
4 11 => 13236300
4 12 => 59043600
4 13 => 227026800
4 14 => 718918200
4 15 => 1702701000
4 16 => 2270268000
5 1 => 2
5 2 => 6
5 3 => 23
5 4 => 100
5 5 => 492
5 6 => 2672
5 7 => 15694
5 8 => 98406
5 9 => 644868
5 10 => 4306932
5 11 => 28544670
5 12 => 182702520
5 13 => 1101620520
5 14 => 6122156040
5 15 => 30739428720
5 16 => 136670133600
5 17 => 524885961600
5 18 => 1667284819200
5 19 => 3959801445600
5 20 => 5279735260800
6 1 => 2
6 2 => 6
6 3 => 23
6 4 => 100
6 5 => 492
6 6 => 2674
6 7 => 15750
6 8 => 99862
6 9 => 674016
6 10 => 4787412
6 11 => 35304654
6 12 => 265314588
6 13 => 1989295308
6 14 => 14559228684
6 15 => 101830348620
6 16 => 667943115840
6 17 => 4042651092480
6 18 => 22264427465280
6 19 => 110258471363040
6 20 => 484855688116800
6 21 => 1854067032417600
6 22 => 5894824418683200
6 23 => 14025616720315200
6 24 => 18700822293753600
7 1 => 2
7 2 => 6
7 3 => 23
7 4 => 100
7 5 => 492
7 6 => 2674
7 7 => 15752
7 8 => 99934
7 9 => 676428
7 10 => 4849212
7 11 => 36601554
7 12 => 288486132
7 13 => 2349550632
7 14 => 19504692636
7 15 => 162272450340
7 16 => 1328431104000
7 17 => 10507447510560
7 18 => 78942848624640
7 19 => 554967220167360
7 20 => 3604592589998400
7 21 => 21411337810262400
7 22 => 115428212139240000
7 23 => 561247297649438400
7 24 => 2439121536313862400
7 25 => 9283622495827680000
7 26 => 29520583763711040000
7 27 => 70328449554723360000
7 28 => 93771266072964480000
8 1 => 2
8 2 => 6
8 3 => 23
8 4 => 100
8 5 => 492
8 6 => 2674
8 7 => 15752
8 8 => 99936
8 9 => 676518
8 10 => 4852992
8 11 => 36722169
8 12 => 291621462
8 13 => 2418755196
8 14 => 20834571186
8 15 => 184894557705
8 16 => 1672561326150
8 17 => 15217247948760
8 18 => 137122338089880
8 19 => 1204392465876600
8 20 => 10153538495100000
8 21 => 81007229522419200
8 22 => 604136189949692400
8 23 => 4168645459350372000
8 24 => 26403795950145213600
8 25 => 152700324078982680000
8 26 => 803784718213396920000
8 27 => 3838761204861983400000
8 28 => 16503742828841748480000
8 29 => 62545434470667308160000
8 30 => 198853691115980300400000
8 31 => 474189571122722254800000
8 32 => 632252761496963006400000

이것들은 코드가 1 분 안에 처리 해야하는 모든 입력 (각각)이지만 더 큰 입력에는 원칙적으로 작동해야합니다. 다음 M = 10테스트 사례 중 일부를 사용 하여이를 확인할 수 있습니다.

10 1 => 2
10 2 => 6
10 3 => 23
10 4 => 100
10 5 => 492
10 6 => 2674
10 7 => 15752
10 8 => 99936
10 9 => 676520
10 10 => 4853104
10 11 => 36727966
10 12 => 291849866
10 13 => 2426074222
10 14 => 21033972388
10 15 => 189645995396
10 16 => 1773525588406
10 17 => 17155884420532
10 18 => 171073929494468
10 19 => 1750412561088334
10 20 => 18258387148774916
10 21 => 192475976310317700
10 22 => 2028834600633220380
10 23 => 21127206177119902860
10 24 => 214639961631544809360
10 25 => 2101478398293813739200
10 26 => 19602967930531817832000
10 27 => 172444768103233181556000
10 28 => 1417975382888905296456000
10 29 => 10820259026484304813416000
10 30 => 76213534343700480310584000
10 31 => 493916052421168703366040000
10 32 => 2941900199368102067135040000
10 33 => 16113144277547868007416960000
10 34 => 81222252655277786422930560000
10 35 => 376309102059179385262246080000
10 36 => 1589579966324953534441910400000
10 37 => 5981477408861097281112374400000
10 38 => 19005991357166148698688124800000
10 39 => 45381652832417130566255318400000
10 40 => 60508870443222840755007091200000

CJam (56 바이트)

q~4@:Nm*:$_&{:+1$\-N),&},f{1$1$:+-\0-:(_e`0f=+++:m!:/}:+

온라인 데모

N$n$$k$mn$M$$N$

$X$$0 \le X \le M$$N-X$$\frac{N!}{X!(N-X)!}$$N-X$$M$$3$

$λ_0, λ_1, \ldots, λ_k$$λ_0$$λ_1$$\frac{(N-X)!}{λ_0! λ_1! ... λ_k!}$$λ_i = λ_j$$μ_i$3 2 2 1$μ_3 = 1$$μ_2 = 2$$μ_1 = 1$$λ_i$$λ_i$

따라서 각 파티션마다 함수 분포의 수는

위의 코드는 Dennis와 동일한 접근 방식을 사용하여 파티션을 계산 한 다음 (확장 가능하지는 않지만 명확하고 짧음) 각 파티션을 [N X λ_0-1 ... λ_k-1 μ_1 μ_2 μ_3]계승 함수를 들어 올린 다음 접을 수있는 것과 유사한 배열로 처리합니다 .

CJam, 74 67 바이트

q~4@:Mm*:$L|{:+W$\-M),&},f{0-:F1@@{_m!\I-:Nm!/I(m!/*N}fI;Fm!Fe=/}:+

Java 인터프리터를 사용하여 데스크탑 컴퓨터의 모든 테스트 사례를 확인했습니다 . 1 ≤ M ≤ 8의 경우 2.2 초 , M = 10의 경우 3.5 분이 걸렸습니다 .

보십시오 이 바이올린 CJam 인터프리터에서 또는 한 번에 최초의 84 테스트 케이스를 확인합니다 .

생각

원칙적으로 각 활성 슬롯과 해당 업그레이드 슬롯을 0 , 1 , 2 또는 3 기능으로 채울 수 있습니다 . 들면 4M의 전체 슬롯, 우리는 모든 벡터 인출 V 의이 {0, 1, 2, 3} ^M 및하는 이러한 필터링 합 (V)> N 또는 (비 패시브 가능한 전체 기능보다는 슬롯 이상의 기능) 합 ( V) + M <N (비활성 기능을위한 수동 슬롯이 충분하지 않음). 슬롯 패밀리의 순서가 중요하지 않기 때문에 모든 유지 벡터를 정렬하고 중복 제거합니다.

와 N의 함수 및 V = (X ₁ , ..., X _M을 ) 다음 슬롯 군의 비 수동 부품의 기능, 우리 조합의 수를 계산한다 :

1. 경우 X ₍₁₎ = 0 , 그 슬롯 군에 대해 하나의 가능성이있다.

   경우 X ₁ = 1 ,가 N의 우리가 있기 때문에, 가능성 N의 기능을하고, 기능은 활성 슬롯에 가야한다.

   x ₁ = 2 인 경우 , 하나의 기능을 활성 슬롯에 배치하고 다른 기능을 업그레이드 슬롯에 배치해야합니다 (어떤 문제는 중요하지 않음). 활성 슬롯 에는 N 개의 선택 항목과 업그레이드 슬롯에는 N-1 개의 나머지 선택 항목이 있으므로 총 N (N-1) 조합이 제공됩니다.

   경우 X ₁ = 3 있다 N의 활성 슬롯에 대한 선택, 1 - N 제 업그레이드 슬롯 선택하고 나머지 N - 2 번째 슬롯에 대한 업그레이드는. 업그레이드 슬롯에는 순서가 없으므로 모든 조합을 두 번 계산하므로 N (N-1) (N-2)의 고유 한 조합이 있습니다.

   어쨌든 N이 있습니다! / ((N - X ₁ ) × (X! ₁ ! - 1) 이 가족을위한 조합.

2. x ₁ 함수를 모두 사용 했으므로 N : = N-x _{1을 설정} 하고 x _2에 대해 1 단계를 반복 한 다음 x ₃ 등을 반복하십시오 .

3. V 에 중복이 포함 된 경우 위 결과의 곱은 모든 조합을 여러 번 계산합니다. 의 고유 한 각 요소에 대해 V ,가 발생 하였을 때 r에 에서 시간을 V , 거기 r은! 이 슬롯 패밀리를 배열하는 동등한 방법이므로 위의 결과는 r에 의해 벗어나야합니다 ! .

4. 최종 결과는 해당 V에 대한 고유 한 조합 수입니다 .

고유 조합의 총 수를 계산하려면 남은 것은 각 V 에 대한 결과의 합계를 계산하는 것 입니다.

암호

q~        e# Read an evaluate all input from STDIN. Pushes M and N.
4@:M      e# Push 4, rotate the M, and formally save it in M.
m*        e# Push {0, 1, 2, 3}^M.
:$        e# Sort each vector.
L|        e# Perform set union with the empty list (deduplicates).
{         e# For each sorted vector:
  :+      e#   Compute the sum of its coordinates.
  W$\-    e#   Subtract the sum from N (bottom of the stack).
  M),&    e#   Push [0 ... M] and intersect.
},        e# If the intersection was not empty, keep the vector.
f{        e# For each kept vector, push N and V; then:
  0-:F    e#   Save the non-zero elements of V in F.
  1@@     e#   Push 1 (accumulator), and rotate N and F on top of it.
  {       e#   For each I in F:
    _m!   e#     Push I and push factorial(I).
    \I-:N e#     Subtract I from N and update N.
    m!/   e#     Divide factorial(N) (original N) by factorial(N) (updated N).
    I(m!/ e#     Divide the quotient by factorial(I - 1).
    *     e#    Multiply the accumulator by the resulting quotient.
    N     e#    Push N for the next iteration.
  }fI     e#
  ;       e#   Pop N.
  Fm!     e#   Push all non-unique permutations of F.
  Fe=     e#   Count the number of times F appears.
  /       e#   Divide the accumulator by the result.
}         e#
:+        e# Add all resulting quotients.