Tres dados indistinguibles

12

Tres dados en un cubo transparente.

Dadas tres tiradas de dados (valores enteros de 1-6) en orden ordenado (para que no se puedan distinguir), conviértalos a la suma de dos dados justos con una distribución idéntica.

La respuesta para tres a uno es sumarlos a todos, módulo 6. El resultado final es una distribución perfectamente plana, donde cada uno de los seis números es igualmente probable (como un solo dado).

Es fácil hacer esto para tres a uno, sumando todos los módulos 6. El resultado final es una distribución perfectamente plana, donde cada uno de los seis números es igualmente probable (como un solo dado). Su desafío es hacer lo mismo para tres a dos.

Inspirado en The Three Indistinguishable Dice Puzzle de standupmath . También se publicó un video de "solución" de seguimiento , pero discutir sobre la "elegancia" de una forma u otra es un poco subjetivo. Contar personajes no lo es.:D

Instrucciones

Escriba un programa o función que acepte tres enteros / dígitos ordenados , 1-6, y genere o devuelva un solo entero, 2-12, de modo que, para las 216 posibles entradas, las salidas se distribuyan como:

 222222
 333333333333
 444444444444444444
 555555555555555555555555
 666666666666666666666666666666
 777777777777777777777777777777777777
 888888888888888888888888888888
 999999999999999999999999
 AAAAAAAAAAAAAAAAAA
 BBBBBBBBBBBB
 CCCCCC

(He usado hexadecimal para mantener caracteres individuales; la salida decimal está bien)

Debido a que los dados son indistinguibles, no hay un orden intrínseco para ellos, de ahí la entrada ordenada. No puedes simplemente "soltar el tercero" porque eso sería ambiguo.

Detalles

  • La puntuación es la longitud del programa en bytes.
  • El programa puede ser una función que se llama de alguna manera, o un script ejecutable que lee de stdin, o lo que sea conveniente.
  • No "re-enrollar" obteniendo entropía de otra fuente

Ejemplo (y prueba)

En lugar de hacer cualquier tipo de prueba probabilística, es bastante fácil analizar los 216 (6³) casos de los tres dados y afirmar que su función devuelve cada valor tantas veces como debería. Se llamará con parámetros idénticos (por ejemplo, los casos 1, 2, 3y 3, 2, 1, ... se presume que no se pueden distinguir y se convierten (arbitrariamente) a 1, 2, 3).

Un ejemplo de respuesta (extremadamente fuerza bruta e ineficiente) y el conjunto de pruebas se proporciona a continuación en Python. Esperemos que los bits de prueba sean lo suficientemente claros como para transferirlos al idioma de su elección, aunque hacer stdin / stdout sería un poco diferente. El código de prueba es solo para pruebas y no está calificado (aunque si desea proporcionarlo a otros usuarios de su idioma o método de E / S, puede ser útil).

# 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
Nick T
fuente
2
Leí la pregunta varias veces y no tengo la menor idea de lo que está pidiendo.
fiesta
1
Además del problema de que este desafío no está claro, los desafíos de código de golf deben puntuarse por bytes en lugar de caracteres, a menos que tenga una buena razón para anular ese valor predeterminado.
Mego
Creo que lo entiendo. La pregunta es pedirnos que asignemos tres tiradas de dados a dos tiradas de dados, con algunas limitaciones.
Leaky Nun
2
No estás haciendo eso con dos dados, estás usando las tres tiradas para simular dos tiradas.
Nick T
2
Tanto (a+b+c)%6+1y (a*b*c)%7convertir un triple de dados no ordenadas a una sola tirada uniforme, pero por desgracia no son probabilísticamente independientes.
xnor

Respuestas:

5

Jalea , 22 20 bytes

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

Pruébalo en línea! o simular los 216 resultados .

Antecedentes

Mapeamos cada triplete desordenado de tiradas de dados (enumerados con las respectivas multiplicidades) a un par ordenado de tiradas de dados de la siguiente manera:

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

Esto hace que todos los resultados sean equiprobables.

Cómo funciona

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.
Dennis
fuente
1

CJam, 25 24 bytes

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

Este es un puerto de mi respuesta Jelly .

Pruébalo en línea! o simular los 216 resultados .

¡Gracias a @ jimmy23013 por jugar golf en 1 byte!

Dennis
fuente
Bueno, debería haber leído el código antes de publicar una respuesta ... Pero un poco de golf simple: 6bW2t1b.
jimmy23013
@ jimmy23013 Bien. ¡Gracias!
Dennis
1

Pyth, 41 27 bytes

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

10 casos de prueba al azar

Confirmación de validez.

Tabla de conversión:

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]

Solución anterior de 41 bytes:

Necesito jugar al golf ...

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

Pruébalo en línea!

Tabla de conversión:

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]
Monja permeable
fuente
1

CJam, 37 35 bytes

Probablemente no haya jugado bien al golf. Pero vencer a Pyth.

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

Pruébalo aquí.

jimmy23013
fuente
Te sugiero que cambies esa descripción.
Leaky Nun