Dado três lançamentos de dados (valores inteiros de 1 a 6) em ordem classificada (de modo a serem indistinguíveis), converta-os na soma de dois dados justos com uma distribuição idêntica.

A resposta de três para um é somar todos eles, módulo 6. O resultado final é uma distribuição perfeitamente plana, onde cada um dos seis números é igualmente provável (como um único dado).

É fácil fazer isso para três para um, somando todos eles no módulo 6. O resultado final é uma distribuição perfeitamente plana, onde cada um dos seis números é igualmente provável (como um único dado). Seu desafio é fazer o mesmo por três a dois.

Inspirado no quebra-cabeça dos três dados indistinguíveis do standupmath . Um vídeo de "solução" de acompanhamento também foi publicado, mas discutir sobre "elegância" de uma maneira ou de outra é um pouco subjetivo. Contar caracteres não é.:D

Instruções

Escrever um programa ou função que aceita três ordenadas inteiros / dígitos, 1-6, e saídas ou retorna uma única inteiros, 2-12, de tal modo que, para os 216 possíveis entradas, as saídas são distribuídos como:

 222222
 333333333333
 444444444444444444
 555555555555555555555555
 666666666666666666666666666666
 777777777777777777777777777777777777
 888888888888888888888888888888
 999999999999999999999999
 AAAAAAAAAAAAAAAAAA
 BBBBBBBBBBBB
 CCCCCC

(Eu usei hex para manter caracteres únicos; a saída decimal é boa)

Como os dados são indistinguíveis, não há ordem intrínseca para eles, daí a entrada classificada. Você não pode simplesmente "largar o terceiro", porque isso seria ambíguo.

Detalhes

• Score é o comprimento do programa em bytes
• O programa pode ser uma função chamada de alguma forma, ou script executável que lê de stdin, ou o que for conveniente.
• Sem "re-rolagem" obtendo entropia de outra fonte

Exemplo (e teste)

Em vez de fazer qualquer tipo de teste probabilístico, é fácil percorrer os 216 (6³) casos dos três dados e afirmar que sua função retorna cada valor quantas vezes for necessário. Ele será chamado com parâmetros idênticos (por exemplo, os casos 1, 2, 3e 3, 2, 1, ... são supostamente indistinguíveis e são (arbitrariamente) convertidos em 1, 2, 3).

Um exemplo de resposta (extremamente bruta e ineficiente) e um conjunto de testes são fornecidos abaixo em Python. Espero que os bits de teste sejam claros o suficiente para serem portados para o idioma de sua escolha, embora fazer stdin / stdout seja um pouco diferente. O código de teste é apenas para teste e não é pontuado (embora se você quiser fornecê-lo para outros usuários do seu idioma ou método de E / S, isso pode 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

Geléia , 22 20 bytes

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

Experimente online! ou simule todos os 216 resultados .

fundo

Mapeamos cada trio não ordenado de jogadas de dados (listado com respectivas multiplicidades) para um par ordenado de jogadas de dados da seguinte maneira:

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

Isso torna todos os resultados equivalentes.

Como 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.

CJam, 25 24 bytes

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

Esta é uma porta da minha resposta Jelly .

Experimente online! ou simule todos os 216 resultados .

Obrigado a @ jimmy23013 por jogar fora um byte!

Pitão, 41 27 bytes

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

10 casos de teste aleatórios

Confirmação de validade.

Tabela de conversão:

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]

Solução anterior de 41 bytes:

Eu preciso jogar golfe ...

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

Experimente online!

Tabela de conversão:

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

Provavelmente não jogou bem. Mas derrote Pyth.

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

Experimente aqui.