Bei drei Würfeln (ganzzahlige Werte von 1 bis 6) in sortierter Reihenfolge (so dass sie nicht zu unterscheiden sind), konvertieren Sie sie in die Summe von zwei fairen Würfeln mit identischer Verteilung.

Die Antwort für drei zu eins ist, sie alle zu summieren, Modulo 6. Das Endergebnis ist eine vollkommen flache Verteilung, bei der jede der sechs Zahlen gleich wahrscheinlich ist (genau wie ein einzelner Würfel).

Es ist einfach, dies für drei zu eins zu tun, indem Sie alle Modulo 6 addieren. Das Endergebnis ist eine vollkommen flache Verteilung, bei der jede der sechs Zahlen gleich wahrscheinlich ist (genau wie ein einzelner Würfel). Ihre Herausforderung besteht darin, dasselbe für drei zu zwei zu tun.

Inspiriert von Standupmaths The Three Indistinguishable Dice Puzzle . Es wurde auch ein "Lösungs" -Video gepostet, aber über "Eleganz" auf die eine oder andere Weise zu streiten, ist ein bisschen subjektiv. Zeichen zählen geht nicht.:D

Anleitung

Schreiben Sie ein Programm oder eine Funktion, die drei sortierte Ganzzahlen / Ziffern (1-6) akzeptiert und eine einzelne Ganzzahl (2-12) ausgibt oder zurückgibt, sodass die Ausgaben für die 216 möglichen Eingaben wie folgt verteilt sind:

 222222
 333333333333
 444444444444444444
 555555555555555555555555
 666666666666666666666666666666
 777777777777777777777777777777777777
 888888888888888888888888888888
 999999999999999999999999
 AAAAAAAAAAAAAAAAAA
 BBBBBBBBBBBB
 CCCCCC

(Ich habe hex verwendet, um einzelne Zeichen beizubehalten; die Dezimalausgabe ist in Ordnung.)

Da die Würfel nicht zu unterscheiden sind, gibt es für sie keine innere Reihenfolge, daher die sortierte Eingabe. Sie können den Dritten nicht einfach "fallen lassen", da dies mehrdeutig wäre.

Einzelheiten

• Score ist die Länge des Programms in Bytes
• Das Programm kann eine Funktion sein, die irgendwie aufgerufen wird, oder ein ausführbares Skript, das von stdin liest, oder was auch immer zweckmäßig ist.
• Kein "Nachrollen" durch Entropie von einer anderen Quelle

Beispiel (und Test)

Anstatt irgendwelche probabilistischen Tests durchzuführen, ist es einfach genug, die 216 (6³) Fälle aller drei Würfel durchzugehen und zu behaupten, dass Ihre Funktion jeden Wert so oft zurückgibt, wie sie sollte. Es wird mit identischen Parametern aufgerufen (zB werden die Fälle 1, 2, 3und 3, 2, 1, ... als nicht unterscheidbar angenommen und (willkürlich) in konvertiert 1, 2, 3).

Eine Beispielantwort (extrem brachial und ineffizient) und eine Testsuite finden Sie weiter unten in Python. Hoffentlich sind die Testbits klar genug, um auf die Sprache Ihrer Wahl zu portieren, obwohl stdin / stdout etwas anders wäre. Der Testcode dient nur zum Testen und wird nicht bewertet (wenn Sie ihn jedoch für andere Benutzer Ihrer Sprache oder E / A-Methode bereitstellen möchten, ist dies möglicherweise hilfreich).

# 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

Jelly , 22 bis 20 Bytes

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

Probieren Sie es online! oder simulieren Sie alle 216 Ergebnisse .

Hintergrund

Wir ordnen jedes ungeordnete Triplett von Würfeln (aufgelistet mit entsprechenden Vielfachen) auf folgende Weise einem geordneten Paar von Würfeln zu:

[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]

Dies macht alle Ergebnisse gleich wahrscheinlich.

Wie es funktioniert

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 Bytes

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

Dies ist eine Portierung meiner Gelee-Antwort .

Probieren Sie es online! oder simulieren Sie alle 216 Ergebnisse .

Vielen Dank an @ jimmy23013 für das Abschlagen von 1 Byte!

Pyth, 41 27 Bytes

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

10 zufällige Testfälle

Bestätigung der Gültigkeit.

Umrechnungstabelle:

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]

Bisherige 41-Byte-Lösung:

Ich muss das Golf spielen ...

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

Probieren Sie es online!

Umrechnungstabelle:

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 Bytes

Wahrscheinlich nicht gut golfen. Aber schlagen Sie Pyth.

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

Probieren Sie es hier aus.