กำหนดลูกเต๋าสามลูก (ค่าจำนวนเต็มตั้งแต่ 1-6) เรียงตามลำดับ (เพื่อแยกไม่ออก) ให้แปลงเป็นผลรวมของลูกเต๋าสองลูกที่มีการแจกแจงที่เหมือนกัน

คำตอบสำหรับสามต่อหนึ่งคือการสรุปพวกเขาทั้งหมดโมดูโล 6 ผลลัพธ์สุดท้ายคือการแจกแจงแบบแบนอย่างสมบูรณ์แบบโดยที่ตัวเลขหกตัวนั้นมีแนวโน้มเท่ากัน (เหมือนตายครั้งเดียว)

มันง่ายมากที่จะทำแบบสามต่อหนึ่งโดยการรวมโมดูโลทั้งหมด 6 ผลลัพธ์สุดท้ายคือการกระจายแบบเรียบที่สมบูรณ์แบบโดยที่ตัวเลขทั้งหกนั้นมีโอกาสเท่ากัน (เหมือนตายครั้งเดียว) ความท้าทายของคุณคือการทำแบบเดียวกันกับสามต่อสอง

แรงบันดาลใจจากเกมไขปริศนาลูกเต๋าสามขั้นที่แยกไม่ออก วิดีโอ "ติดตาม"ติดตามก็โพสต์ แต่การโต้เถียงเกี่ยวกับ "ความสง่างาม" ของทางใดทางหนึ่งเป็นเรื่องส่วนตัว การนับจำนวนตัวอักษรไม่ใช่:D

คำแนะนำ

เขียนโปรแกรมหรือฟังก์ชั่นที่ยอมรับเลขจำนวนเต็ม / ตัวเลขที่เรียงลำดับ 1-6 และส่งออกหรือส่งกลับจำนวนเต็มเดียว 2-12 เช่นนั้นสำหรับอินพุตที่เป็นไปได้ 216 รายการผลลัพธ์จะถูกกระจายเป็น:

 222222
 333333333333
 444444444444444444
 555555555555555555555555
 666666666666666666666666666666
 777777777777777777777777777777777777
 888888888888888888888888888888
 999999999999999999999999
 AAAAAAAAAAAAAAAAAA
 BBBBBBBBBBBB
 CCCCCC

(ฉันใช้เลขฐานสิบหกเพื่อเก็บไว้ที่ตัวอักษรเดียวเอาต์พุตทศนิยมไม่เป็นไร)

เนื่องจากลูกเต๋าไม่สามารถแยกแยะได้จึงไม่มีคำสั่งที่แท้จริงให้กับพวกเขาดังนั้นอินพุตที่เรียงลำดับแล้ว คุณไม่สามารถ "ดรอปครั้งที่สาม" เพียงเพราะไม่ชัดเจน

รายละเอียด

• คะแนนคือความยาวของโปรแกรมเป็นไบต์
• โปรแกรมสามารถเป็นฟังก์ชั่นที่เรียกว่าอย่างใดหรือสคริปต์ปฏิบัติการที่อ่านจาก stdin หรืออะไรก็ตามที่มั่นใจ
• ไม่มี "rerolling" โดยรับเอนโทรปีจากแหล่งอื่น

ตัวอย่าง (และทดสอบ)

แทนที่จะทำการทดสอบความน่าจะเป็นประเภทใด ๆ ก็ง่ายพอที่จะตัดผ่านกรณี 216 (6³) ของทั้งสามลูกเต๋าและยืนยันว่าฟังก์ชันของคุณคืนค่าแต่ละค่าเท่าที่ควร มันจะถูกเรียกด้วยพารามิเตอร์ที่เหมือนกัน (เช่นกรณี1, 2, 3และ3, 2, 1, ... สันนิษฐานว่าแยกไม่ออกและถูกแปลง (โดยพลการ) เป็น1, 2, 3)

ตัวอย่างคำตอบ (แรงเดรัจฉานแรงมากและไม่มีประสิทธิภาพ) และชุดทดสอบมีให้ใน Python หวังว่าบิตทดสอบจะชัดเจนพอที่จะพอร์ตกับภาษาที่คุณเลือกแม้ว่าการทำ stdin / stdout จะแตกต่างกันเล็กน้อย รหัสการทดสอบนั้นใช้สำหรับการทดสอบและไม่ได้คะแนน (แม้ว่าคุณจะต้องการให้รหัสดังกล่าวกับผู้ใช้ภาษาอื่นหรือวิธีการ I / O ของคุณอาจเป็นประโยชน์)

# 6x6 lists of numbers with digits sorted
LUT = [
    [[124], [133, 166], [346], [223, 355], [256], [115, 445]],
    [[233, 266], [125], [224, 455], [134], [116, 446], [356]],
    [[126], [111, 333, 555, 225], [234], [144, 366], [456], [135]],
    [[112, 244], [235], [334, 466], [145], [226, 556], [136]],
    [[146], [122, 155], [236], [113, 344], [245], [335, 566]],
    [[246], [123], [114, 336], [345], [222, 444, 666, 255], [156]],
]

def three2two(rolls):
    look_for = int('{}{}{}'.format(*sorted(rolls)))
    for i in range(6):
        for j in range(6):
            if look_for in LUT[i][j]:
                return i + j + 2

# fair distribution of the sum of two dice multiplied by 6 (because each should be hit 6x)
expected_counts = {
    2: 6,   12: 6,
    3: 12,  11: 12,
    4: 18,  10: 18,
    5: 24,   9: 24,
    6: 30,   8: 30,
    7: 36,
}

d = [1, 2, 3, 4, 5, 6]
for i in d:
    for j in d:
        for k in d:
            ijk = sorted([i, j, k])
            result = three2two(ijk)
            expected_counts[result] -= 1

for key in expected_counts:
    assert expected_counts[key] == 0

เยลลี่ , 22 20 ไบต์

6ṗ3Ṣ€ṢðQ€L€Ụịḷi’:6d6‘S

ลองออนไลน์! หรือจำลองผลลัพธ์ทั้งหมด 216รายการ

พื้นหลัง

เราจับคู่ triplet ที่ไม่มีการเรียงลำดับของลูกเต๋า (ตามรายการที่มีหลายหลากตามลำดับ) กับคู่ลูกเต๋าที่สั่งในแบบต่อไปนี้:

[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3],[1,2,3] -> [1,1]
[1,2,4],[1,2,4],[1,2,4],[1,2,4],[1,2,4],[1,2,4] -> [1,2]
[1,2,5],[1,2,5],[1,2,5],[1,2,5],[1,2,5],[1,2,5] -> [1,3]
[1,2,6],[1,2,6],[1,2,6],[1,2,6],[1,2,6],[1,2,6] -> [1,4]
[1,3,4],[1,3,4],[1,3,4],[1,3,4],[1,3,4],[1,3,4] -> [1,5]
[1,3,5],[1,3,5],[1,3,5],[1,3,5],[1,3,5],[1,3,5] -> [1,6]
[1,3,6],[1,3,6],[1,3,6],[1,3,6],[1,3,6],[1,3,6] -> [2,1]
[1,4,5],[1,4,5],[1,4,5],[1,4,5],[1,4,5],[1,4,5] -> [2,2]
[1,4,6],[1,4,6],[1,4,6],[1,4,6],[1,4,6],[1,4,6] -> [2,3]
[1,5,6],[1,5,6],[1,5,6],[1,5,6],[1,5,6],[1,5,6] -> [2,4]
[2,3,4],[2,3,4],[2,3,4],[2,3,4],[2,3,4],[2,3,4] -> [2,5]
[2,3,5],[2,3,5],[2,3,5],[2,3,5],[2,3,5],[2,3,5] -> [2,6]
[2,3,6],[2,3,6],[2,3,6],[2,3,6],[2,3,6],[2,3,6] -> [3,1]
[2,4,5],[2,4,5],[2,4,5],[2,4,5],[2,4,5],[2,4,5] -> [3,2]
[2,4,6],[2,4,6],[2,4,6],[2,4,6],[2,4,6],[2,4,6] -> [3,3]
[2,5,6],[2,5,6],[2,5,6],[2,5,6],[2,5,6],[2,5,6] -> [3,4]
[3,4,5],[3,4,5],[3,4,5],[3,4,5],[3,4,5],[3,4,5] -> [3,5]
[3,4,6],[3,4,6],[3,4,6],[3,4,6],[3,4,6],[3,4,6] -> [3,6]
[3,5,6],[3,5,6],[3,5,6],[3,5,6],[3,5,6],[3,5,6] -> [4,1]
[4,5,6],[4,5,6],[4,5,6],[4,5,6],[4,5,6],[4,5,6] -> [4,2]
[1,2,2],[1,2,2],[1,2,2],[1,3,3],[1,3,3],[1,3,3] -> [4,3]
[1,4,4],[1,4,4],[1,4,4],[1,5,5],[1,5,5],[1,5,5] -> [4,4]
[1,6,6],[1,6,6],[1,6,6],[2,3,3],[2,3,3],[2,3,3] -> [4,5]
[2,4,4],[2,4,4],[2,4,4],[2,5,5],[2,5,5],[2,5,5] -> [4,6]
[2,6,6],[2,6,6],[2,6,6],[3,4,4],[3,4,4],[3,4,4] -> [5,1]
[3,5,5],[3,5,5],[3,5,5],[3,6,6],[3,6,6],[3,6,6] -> [5,2]
[4,5,5],[4,5,5],[4,5,5],[4,6,6],[4,6,6],[4,6,6] -> [5,3]
[5,6,6],[5,6,6],[5,6,6],[1,1,2],[1,1,2],[1,1,2] -> [5,4]
[1,1,3],[1,1,3],[1,1,3],[1,1,4],[1,1,4],[1,1,4] -> [5,5]
[1,1,5],[1,1,5],[1,1,5],[1,1,6],[1,1,6],[1,1,6] -> [5,6]
[2,2,3],[2,2,3],[2,2,3],[2,2,4],[2,2,4],[2,2,4] -> [6,1]
[2,2,5],[2,2,5],[2,2,5],[2,2,6],[2,2,6],[2,2,6] -> [6,2]
[3,3,4],[3,3,4],[3,3,4],[3,3,5],[3,3,5],[3,3,5] -> [6,3]
[3,3,6],[3,3,6],[3,3,6],[4,4,5],[4,4,5],[4,4,5] -> [6,4]
[4,4,6],[4,4,6],[4,4,6],[5,5,6],[5,5,6],[5,5,6] -> [6,5]
[1,1,1],[2,2,2],[3,3,3],[4,4,4],[5,5,5],[6,6,6] -> [6,6]

สิ่งนี้ทำให้ผลลัพธ์ทั้งหมดเป็นไปได้

มันทำงานอย่างไร

6ṗ3Ṣ€ṢðĠ€Ụịḷi’:6d6‘S  Main link. Argument: D (three dice rolls, sorted)

6ṗ3                     Generate lists of length 3 over [1, 2, 3, 4, 5, 6].
   Ṣ€                   Sort each triplet.
     Ṣ                  Sort the list of triplets.
      ð                 Begin a new, dyadic chain.
                        Arguments: A (list of triplets), D
       Ġ€               Group each; group the indices of each triplet by the
                        the corresponding values.
                        For a triplet [a, b, c], this yields:
                          [[1], [2], [3]] if a < b < c
                          [[1], [2, 3]]   if a < b = c
                          [[1, 2], [3]]   if a = b < c
                          [[1, 2, 3]]     if a = b = c
           Ụ            Grade up; sort the indices of A by those 2D lists.
            ịḷ          Retrieve the elements of A at those indices.
                        This sorts A as in the previous section.
              i         Find the (1-based) index of D.
               ’        Decrement to get the 0-based index.
                :6      Divide the index by 6, rounding down.
                  d6    Divmod; return quotient and remainder of division by 6.
                    ‘   Increment to map [0, ..., 5] to [1, ..., 6].
                     S  Sum the results.

CJam, 25 24 ไบต์

6Zm*{$e`z}$q~:(a#6bW2t1b

นี่คือพอร์ตของคำตอบของฉัน Jelly

ลองออนไลน์! หรือจำลองผลลัพธ์ทั้งหมด 216รายการ

ขอบคุณ @ jimmy23013 สำหรับการตีกอล์ฟ 1 ไบต์!

Pyth, 41 27 ไบต์

JSSM^S6 3+2sPtj+216xo/JNJQ6

10 สุ่มทดสอบ

การยืนยันความถูกต้อง

ตารางการแปลง:

2: [111, 222, 333, 444, 555, 666]
3: [112, 113, 223, 224]
4: [114, 115, 225, 226, 355, 366]
5: [116, 122, 125, 233, 244, 445, 446]
6: [126, 133, 144, 146, 255, 266, 455, 466]
7: [134, 155, 156, 166, 246, 334, 335, 556, 566]
8: [123, 135, 234, 256, 336, 344]
9: [124, 136, 235, 345]
10: [145, 236, 346]
11: [245, 356]
12: [456]

โซลูชัน 41 ไบต์ก่อนหน้า:

ฉันต้องตีกอล์ฟนี้ ...

JSM^S6 3+2f/@co,/JNNJ.u+NY*R6t+S5_S6 6TQ0

ลองออนไลน์!

ตารางการแปลง:

2: [111, 222, 333, 444, 555, 666]

3: [112, 113, 114, 115]

4: [116, 122, 133, 144, 155, 166]

5: [223, 224, 225, 226, 233, 244, 255, 266]

6: [334, 335, 336, 344, 355, 366, 445, 446, 455, 466]

7: [556, 566, 123, 124, 125, 126, 134]

8: [135, 136, 145, 146, 156]

9: [234, 235, 236, 245]

10: [246, 256, 345]

11: [346, 356]

12: [456]

CJam, 37 35 ไบต์

อาจจะไม่ค่อยดีนักกอล์ฟ แต่เอาชนะ Pyth

8aq~\;[_2$>8+@7+@:U2+1$([8U4$7]])er

ลองที่นี่