ビデオゲームのトランジスターは非常に興味深い能力システムを備えています。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.

これらの再配置の任意の組み合わせと同様に。3番目のケースでは、同じ全体的な効果を維持するために、アップグレードスロットがアクティブスロットと交換されていることに注意してください。

一方、次の組み合わせはすべて上記のセットとは異なります。

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個未満の場合、一部のスロットは空のままになります。ただし、親アクティブスロットが空の場合、アップグレードスロットに関数を配置できないことに注意してください。

チャレンジ

使用できる機能の数に応じて、可能な構成の数を決定する必要があります。さらに、些細なハードコーディングの解決策を防ぐために、スロットの数を可変にして問題を少し一般化します。

2つの正の整数M ≥ 1とが与えられると1 ≤ N ≤ 4M、パッシブ、アクティブ、アップグレードスロットNをできるだけ多く埋めるためにまったく異なる関数が使用されると仮定して、可能な（機能的に異なる）スキルセットの数を決定するプログラムまたは関数を記述します。MM2M

プログラムまたは関数を作成し、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$

したがって、各パーティションの関数の分布数は

上記のコードは、デニスと同じアプローチを使用してパーティションを計算し（スケーラブルではありませんが、明らかで短く）、各パーティションを[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インタープリターを使用して、デスクトップコンピューター上のすべてのテストケースを検証しました。これがために2.2秒を要した1≤M≤8用と3.5分M = 10。

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の場合、そのスロットファミリの可能性は1つだけです。

   x ₁ = 1の場合、N個の関数があるため、N個の可能性があり、関数はアクティブスロットに配置する必要があります。

   x ₁ = 2の場合、1つの機能をアクティブスロットに配置し、別の機能をアップグレードスロットに配置する必要があります（どちらでもかまいません）。アクティブスロットにはN個の選択肢があり、アップグレードスロットにはN-1 個の選択肢があり、合計N（N-1）の組み合わせが得られます。

   場合X ₁ = 3、あるN個のアクティブなスロットの選択肢、1 - N最初のアップグレードスロットの残りの選択肢及びN - 2第アップグレードスロットのは。アップグレードスロットには順序がないため、すべての組み合わせが2回カウントされるため、N（N-1）（N-2）個の一意の組み合わせがあります。

   いずれにせよ、N！/（（N - X ₁）×（X！₁！ - 1）この家族のための組み合わせ。

2. x _1個の関数を使い切ったので、N：= N-x ₁を設定し、x ₂に対してステップ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.