Étant donné trois lancers de dés (valeurs entières de 1 à 6) dans un ordre trié (afin de ne pas les distinguer), convertissez-les en la somme de deux dés équitables avec une distribution identique.

La réponse pour trois contre un est de les résumer tous, modulo 6. Le résultat final est une distribution parfaitement plate, où chacun des six nombres est également probable (comme un seul dé).

Il est facile de le faire en trois contre un, en les sommant tous modulo 6. Le résultat final est une distribution parfaitement plate, où chacun des six nombres est également probable (tout comme un seul dé). Votre défi est de faire de même pour trois contre deux.

Inspiré par le casse-tête des trois cubes indiscernables de standupmath . Une vidéo de "solution" de suivi a également été publiée, mais argumenter sur "l'élégance" d'une manière ou d'une autre est un peu subjectif. Le comptage des caractères ne l'est pas.:D

Instructions

Écrivez un programme ou une fonction qui accepte trois entiers / chiffres triés , 1-6, et génère ou renvoie un seul entier, 2-12, de sorte que, pour les 216 entrées possibles, les sorties sont réparties comme suit:

 222222
 333333333333
 444444444444444444
 555555555555555555555555
 666666666666666666666666666666
 777777777777777777777777777777777777
 888888888888888888888888888888
 999999999999999999999999
 AAAAAAAAAAAAAAAAAA
 BBBBBBBBBBBB
 CCCCCC

(J'ai utilisé hex pour conserver des caractères uniques; la sortie décimale est très bien)

Parce que les dés sont indiscernables, il n'y a pas d'ordre intrinsèque pour eux, d'où l'entrée triée. Vous ne pouvez pas simplement "laisser tomber le troisième" car ce serait ambigu.

Détails

• Le score est la longueur du programme en octets
• Le programme peut être une fonction qui est appelée d'une manière ou d'une autre, ou un script exécutable qui lit à partir de stdin, ou tout ce qui convient.
• Pas de "relance" en obtenant l'entropie d'une autre source

Exemple (et test)

Plutôt que de faire une sorte de test probabiliste, il est assez facile de déchiffrer les 216 (6³) cas des trois dés et d'affirmer que votre fonction renvoie chaque valeur autant de fois qu'elle le devrait. Il sera appelé avec des paramètres identiques (par exemple, les cas 1, 2, 3et 3, 2, 1, ... sont présumés indiscernables et sont (arbitrairement) convertis en 1, 2, 3).

Un exemple de réponse (extrêmement brutale et inefficace) et une suite de tests sont fournis ci-dessous en Python. Espérons que les bits de test soient suffisamment clairs pour être portés dans la langue de votre choix, bien que faire stdin / stdout soit un peu différent. Le code de test est juste pour le test et n'est pas noté (bien que si vous souhaitez le fournir à d'autres utilisateurs de votre langue ou de votre méthode d'E / S, cela pourrait être utile).

# 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

Gelée , 22 20 octets

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

Essayez-le en ligne! ou simulez les 216 résultats .

Contexte

Nous mappons chaque triplet non ordonné de lancers de dés (répertoriés avec les multiplicités respectives) sur une paire ordonnée de lancers de dés de la manière suivante:

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

Cela rend tous les résultats équiprobables.

Comment ça fonctionne

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 octets

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

Ceci est un portage de ma réponse Jelly .

Essayez-le en ligne! ou simulez les 216 résultats .

Merci à @ jimmy23013 pour avoir joué au golf sur 1 octet!

Pyth, 41 27 octets

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

10 cas de test aléatoires

Confirmation de validité.

Table de conversion:

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]

Solution précédente de 41 octets:

J'ai besoin de jouer au golf ...

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

Essayez-le en ligne!

Table de conversion:

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 octets

Probablement pas bien joué au golf. Mais battez Pyth.

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

Essayez-le ici.