20

วิดีโอเกมทรานซิสเตอร์มีระบบความสามารถที่น่าสนใจมาก คุณรวบรวม 16 "ฟังก์ชั่น" ซึ่งคุณสามารถใช้ในช่องที่แตกต่างกัน 16 ช่อง สิ่งที่น่าสนใจคือมีสล็อต 3 ประเภทและทุกฟังก์ชั่นจะทำงานแตกต่างกันไปตามช่องที่คุณใช้ใน:

มี4 ช่องเรื่อย ๆ
มี4 สล็อตที่ใช้งานอยู่
แต่ละช่องใช้งานมี2 สล็อตอัพเกรด

เราต้องการทราบว่าทักษะที่แตกต่างกันนั้นให้

อย่างไรก็ตามชุดค่าผสมบางชุดมีค่าเทียบเท่า โดยเฉพาะอย่างยิ่งภายในแต่ละกลุ่มของช่องเหล่านั้นตำแหน่งเฉพาะของฟังก์ชั่นไม่สำคัญ ในทางกลับกันเอฟเฟกต์ของฟังก์ชั่นในสล็อตอัพเกรดจะขึ้นอยู่กับฟังก์ชั่นเฉพาะที่ใช้ใน Active Slot แม่

ดังนั้นการใช้เลขฐานสิบหกเพื่อใช้ในฟังก์ชั่นชุดค่าผสมต่อไปนี้จึงเทียบเท่ากันทั้งหมด:

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 ฟังก์ชั่นการใช้งานบางช่องจะว่างเปล่า อย่างไรก็ตามโปรดทราบว่าคุณไม่สามารถวางฟังก์ชั่นในช่องอัพเกรดได้หากช่องหลักที่ใช้งานอยู่ว่างเปล่า

ความท้าทาย

คุณต้องกำหนดจำนวนของการกำหนดค่าที่เป็นไปได้ทั้งนี้ขึ้นอยู่กับจำนวนฟังก์ชันที่คุณมี นอกจากนี้ฉันจะพูดคุยปัญหาทั่วไปเล็กน้อยโดยกำหนดจำนวนตัวแปร slot เพื่อป้องกันการแก้ปัญหาการเข้ารหัสฮาร์ดไดรฟ์เล็กน้อย

เขียนโปรแกรมหรือฟังก์ชั่นที่ได้รับสองจำนวนเต็มบวกM ≥ 1และ1 ≤ N ≤ 4Mกำหนดจำนวนที่เป็นไปได้ (ตามหน้าที่ที่แตกต่างกัน) ชุดทักษะสมมติว่าNฟังก์ชั่นที่แตกต่างกันจะใช้ในการกรอกข้อมูลให้มากที่สุดเท่าที่เป็นไปได้Mเรื่อย ๆ , Mใช้งานอยู่และ2Mอัพเกรดเครื่องหยอดเหรียญ

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่น, รับอินพุตผ่าน STDIN (หรือทางเลือกที่ใกล้เคียงที่สุด), อาร์กิวเมนต์บรรทัดคำสั่งหรืออาร์กิวเมนต์ของฟังก์ชันและส่งผลลัพธ์ผ่าน STDOUT (หรือทางเลือกที่ใกล้เคียงที่สุด), ค่าส่งคืนของฟังก์ชันหรือพารามิเตอร์

รหัสของคุณจะต้องสามารถจัดการกับการป้อนข้อมูลใด ๆ ถึงและรวมถึงM = 8ภายในหนึ่งนาทีบนเครื่องเดสก์ทอปที่เหมาะสม มีบางอย่างในระยะนี้ แต่ควรออกกฎแรงเดรัจฉาน โดยหลักการแล้วมันไม่ควรที่จะแก้ปัญหาอินพุตใด ๆ เหล่านั้นในเวลาน้อยกว่าหนึ่งวินาที

นี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

กรณีทดสอบ

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

นี่คืออินพุตทั้งหมดที่โค้ดของคุณต้องจัดการภายในหนึ่งนาที (แต่ละอัน) แต่โดยหลักการแล้วมันควรจะทำงานเพื่ออินพุตที่ใหญ่กว่า คุณสามารถใช้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

— Martin Ender
แหล่งที่มา

จำเป็นต้องกรอกข้อมูลให้มากที่สุดเท่าที่จะเป็นไปได้หรือไม่?

— feersum

7

ฉันเดาว่าฉันจะรอให้ดีturn()ก่อนที่ฉันhelp()จะget()ตอบคำถามใด ๆload()หรืออื่น ๆ ที่ฉันอาจต้องการให้ping()คุณvoid()หลังจากฉันspark()และcrash()..... คน ...

— FryAmTheEggman

@feersum ใช่Nฟังก์ชั่นทั้งหมดใช้งานอยู่

— Martin Ender

18

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$

ดังนั้นสำหรับแต่ละพาร์ติชั่นจำนวนการแจกแจงของฟังก์ชั่นคือ

\frac{N!}{X! (λ_{0} - 1)! \dots (λ_{k} - 1)! μ_{1}! μ_{2}! μ_{3}!}

$\frac{N!}{X! (λ_0-1)! \ldots (λ_k-1)! μ_1! μ_2! μ_3!}$

โค้ดข้างต้นคำนวณพาร์ติชั่นโดยใช้วิธีการเดียวกับเดนนิส (มันชัดเจนและสั้น แต่ไม่สามารถปรับขนาดได้มาก) จากนั้นประมวลผลแต่ละพาร์ติชั่นเป็นอาเรย์ที่คล้ายกับ[N X λ_0-1 ... λ_k-1 μ_1 μ_2 μ_3]ที่มันสามารถยกฟังก์ชันแฟกทอเรียล

— ปีเตอร์เทย์เลอร์
แหล่งที่มา

9

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และกรองรายการที่sum (V)> N (ฟังก์ชั่นเพิ่มเติมในสล็อตที่ไม่ใช่แบบพาสซีฟมากกว่าฟังก์ชั่นทั้งหมดที่มี) หรือผลรวม V) + M <N (ช่องเสียบแฝงไม่เพียงพอสำหรับฟังก์ชั่นที่ไม่ทำงาน) เราจัดเรียงและขจัดข้อมูลซ้ำซ้อนทั้งหมดเก็บเวกเตอร์เนื่องจากลำดับของตระกูลสล็อตไม่สำคัญ

ด้วยฟังก์ชั่นNและV = (x ₁ , …, x _M )ฟังก์ชั่นในส่วนที่ไม่มีการโต้ตอบของตระกูลสล็อตเราจึงคำนวณจำนวนชุดค่าผสมดังนี้:

ถ้าx ₁ = 0มีความเป็นไปได้เพียงทางเดียวสำหรับตระกูลสล็อตนั้น

ถ้าx ₁ = 1จะมีความเป็นไปได้Nเนื่องจากเรามีฟังก์ชั่นNและฟังก์ชั่นจะต้องอยู่ในช่องเสียบที่ใช้งานอยู่

หากx ₁ = 2เราจะต้องวางฟังก์ชันหนึ่งไว้ในช่องเสียบที่ใช้งานและอีกช่องหนึ่งในช่องอัปเกรด มีตัวเลือกNสำหรับช่องเสียบที่ใช้งานอยู่และตัวเลือกN-1ที่เหลืออยู่สำหรับช่องอัปเกรดซึ่งมีชุดรวมN (N-1)ทั้งหมด

หากx ₁ = 3จะมีตัวเลือกNสำหรับช่องเสียบที่ใช้งานอยู่ตัวเลือกที่เหลือN - 1สำหรับช่องอัพเกรดแรกและN - 2สำหรับช่องอัพเกรดที่สอง ตั้งแต่ช่องอัพเกรดไม่มีการสั่งซื้อนับรวมกันเช่นนี้ทุกครั้งที่สองจึงมีN (N - 1) (N - 2)ชุดที่ไม่ซ้ำ

ไม่ว่าในกรณีใด ๆ มีN! / ((N - x ₁ )! ×× (x ₁ - 1)รวมกันสำหรับครอบครัวนี้
เราใช้ฟังก์ชั่นมากขึ้นx ₁ดังนั้นให้ตั้งN: = N - x ₁และทำซ้ำขั้นตอนที่ 1 สำหรับx ₂จากนั้นx ₃เป็นต้น
หากVมีรายการที่ซ้ำกันผลิตภัณฑ์ของผลลัพธ์ด้านบนจะนับชุดค่าผสมทั้งหมดหลายครั้ง สำหรับองค์ประกอบที่ไม่ซ้ำกันของแต่ละVถ้ามันเกิดขึ้นRครั้งในVมีอา! วิธีที่เท่าเทียมกันในการจัดเรียงตระกูลสล็อตเหล่านี้ดังนั้นผลลัพธ์จากด้านบนจะต้องถูกเบี่ยงเบนโดยr! .
ผลลัพธ์สุดท้ายคือจำนวนชุดค่าผสมที่ไม่ซ้ำกันสำหรับ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.

— เดนนิส
แหล่งที่มา

Combinatorics ของทรานซิสเตอร์