Trò chơi điện tử Transistor có hệ thống khả năng rất thú vị. Bạn thu thập 16 "Chức năng" mà bạn có thể sử dụng trong 16 vị trí khác nhau. Điều thú vị là có 3 loại vị trí và mọi Chức năng hoạt động khác nhau tùy theo vị trí bạn sử dụng vị trí đó:

• Có 4 Slots thụ động .
• Có 4 khe hoạt động .
• Mỗi khe hoạt động có 2 khe nâng cấp .

Chúng tôi muốn tìm hiểu có bao nhiêu bộ kỹ năng khác nhau mang lại cho chúng tôi.

Tuy nhiên, một số kết hợp là tương đương. Đặc biệt, trong mỗi nhóm vị trí đó, vị trí cụ thể của Hàm không quan trọng. Mặt khác, hiệu quả của một hàm trong một khe cắm nâng cấp không phụ thuộc vào các chức năng cụ thể được sử dụng trong phụ huynh tích cực Khe cắm.

Do đó, sử dụng các chữ số thập lục phân để thay thế cho các Hàm, các kết hợp sau đây đều tương đương:

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.

cũng như bất kỳ sự kết hợp của những sắp xếp lại. Lưu ý rằng trong trường hợp thứ ba, các Slots Nâng cấp đã được hoán đổi cùng với Active Slots để duy trì hiệu ứng tổng thể tương tự.

Mặt khác, các kết hợp sau đây đều khác với bộ trên:

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.

Theo tính toán của tôi, nó cung cấp cho bạn 2.270.268.000 kết hợp có thể (khác biệt về chức năng), giả sử tất cả các Hàm được sử dụng.

Nếu bạn có ít hơn 16 Hàm theo ý của bạn, một số vị trí sẽ vẫn trống. Tuy nhiên, lưu ý rằng bạn không thể đặt Chức năng trong Khe nâng cấp nếu Khe hoạt động chính trống.

Các thách thức

Bạn sẽ xác định số lượng cấu hình có thể tùy thuộc vào số lượng chức năng bạn có. Hơn nữa, tôi sẽ khái quát hóa vấn đề một chút bằng cách làm cho số lượng vị trí biến đổi, để ngăn chặn các giải pháp mã hóa tầm thường.

Viết chương trình hoặc hàm, cho hai số nguyên dương M ≥ 1và 1 ≤ N ≤ 4M, xác định số lượng bộ kỹ năng có thể (khác biệt về chức năng) giả sử Ncác Hàm chính xác khác nhau được sử dụng để điền vào càng nhiều càng tốt các Khe Mthụ động, MHoạt động và 2MNâng cấp.

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Mã của bạn phải có khả năng xử lý bất kỳ đầu vào nào và bao gồm M = 8trong vòng một phút trên máy tính để bàn hợp lý. Có một số chậm trễ trong việc này, nhưng nó nên loại trừ các giải pháp vũ phu. Về nguyên tắc, sẽ không có vấn đề gì khi giải quyết bất kỳ đầu vào nào trong chưa đầy một giây.

Đây là mã golf, câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

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

Mỗi trường hợp thử nghiệm là trong mẫu 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

Đây là tất cả các đầu vào mà mã của bạn phải xử lý trong vòng một phút (mỗi), nhưng về nguyên tắc, nó sẽ hoạt động cho các đầu vào lớn hơn. Bạn có thể sử dụng một số M = 10trường hợp kiểm tra sau để kiểm tra xem:

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 byte)

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

Bản demo trực tuyến

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$

Vì vậy, đối với mỗi phân vùng, số lượng phân phối của các hàm là

Đoạn mã trên tính toán các phân vùng bằng cách sử dụng cùng một cách tiếp cận với Dennis (rõ ràng và ngắn, mặc dù không có khả năng mở rộng) và sau đó xử lý mỗi phân vùng thành một mảng tương tự như [N X λ_0-1 ... λ_k-1 μ_1 μ_2 μ_3]nó có thể nâng chức năng giai thừa và sau đó gập phân chia.

CJam, 74 67 byte

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

Tôi đã xác minh tất cả các trường hợp thử nghiệm trên máy tính để bàn của mình bằng trình thông dịch Java . Quá trình này mất 2,2 giây cho 1 ≤ M 8 và 3,5 phút cho M = 10 .

Hãy thử câu đố này trong trình thông dịch của CJam hoặc xác minh 84 trường hợp thử nghiệm đầu tiên cùng một lúc .

Ý kiến

Về nguyên tắc, chúng ta có thể lấp đầy từng khe hoạt động và các khe nâng cấp tương ứng của nó với các hàm 0 , 1 , 2 hoặc 3 . Đối với 4M khe trong tổng số, chúng ta lấy tất cả các vector V của {0, 1, 2, 3} ^M và lọc ra những mà sum (V)> N (thêm chức năng trong khe không thụ động hơn tổng các chức năng có sẵn) hoặc sum ( V) + M <N (không đủ vị trí thụ động cho các chức năng không hoạt động). Chúng tôi sắp xếp và sao chép tất cả các vectơ được giữ, vì thứ tự của các họ khe không quan trọng.

Với các hàm N và các hàm V = (x ₁ , chụp, x _M ) trong các phần không thụ động của các họ vị trí, chúng tôi tính toán số lượng kết hợp như sau:

1. Nếu x ₁ = 0 , chỉ có một khả năng cho họ vị trí đó.

   Nếu x ₁ = 1 , có N khả năng, vì chúng ta có N hàm và hàm phải đi trong khe hoạt động.

   Nếu x ₁ = 2 , chúng ta phải đặt một chức năng trong vị trí hoạt động và chức năng khác trong vị trí nâng cấp (không thành vấn đề). Có N lựa chọn cho vị trí hoạt động và N-1 lựa chọn còn lại cho vị trí nâng cấp, đưa ra tổng số kết hợp N (N-1) .

   Nếu x ₁ = 3 , có N lựa chọn cho vị trí hoạt động, N - 1 lựa chọn cho vị trí nâng cấp đầu tiên và N - 2 cho vị trí nâng cấp thứ hai. Vì các vị trí nâng cấp không có thứ tự, nên số lần kết hợp này được tính hai lần, do đó, có các kết hợp duy nhất N (N - 1) (N - 2) .

   Trong mọi trường hợp, có N! / ((N - x ₁ )! × (x ₁ - 1)! Kết hợp cho gia đình này.

2. Chúng tôi đã sử dụng hết các hàm x ₁ , vì vậy, đặt N: = N - x ₁ và lặp lại bước 1 cho x ₂ , sau đó x ₃ , v.v.

3. Nếu V chứa các bản sao, sản phẩm của các kết quả trên sẽ được tính tất cả các kết hợp nhiều lần. Đối với mỗi phần tử duy nhất của V , nếu xảy ra r lần trong V , có r! cách tương đương để sắp xếp các họ khe này, vì vậy kết quả từ phía trên phải được chia theo r! .

4. Kết quả cuối cùng là số kết hợp duy nhất cho rằng V .

Để tính toán tổng số kết hợp độc đáo, tất cả những gì đã phải rời làm là để tính tổng các kết quả cho từng V .

Mã

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.