Escriba el programa o función que tomará el valor izquierdo y derecho de los dados como enteros (1-6) y devolverá el valor en la parte superior.

Diseño de dados:

    +---+
    | 1 |
+---+---+---+---+
| 2 | 3 | 5 | 4 |
+---+---+---+---+
    | 6 |
    +---+

  ,^.
<´ 5 `>  <-- Top value
|`._,´|
.6 | 4,  <-- Side values
 `.|,´

Entonces la entrada 6 4volverá 5.

El orden es importante:

2 3 -> 1
3 2 -> 6

El programa no tiene que funcionar con valores de entrada no válidos.

Para desalentar el enfoque obvio (usando la tabla con todas las combinaciones), no está permitido usar ninguna codificación de texto incorporada o rutinas de descompresión / compresión o codificación base o cualquier otra cosa similar para reducir el tamaño. Tenga en cuenta que todavía se permite el uso de la tabla y también se permite rodar su propia descompresión, siempre que no se haga con alguna función de biblioteca lista.

Para fines de referencia, aquí hay una tabla de todas las combinaciones (es decir, todas las entradas y salidas posibles):

23, 35, 42, 54 -> 1
14, 31, 46, 63 -> 2
12, 26, 51, 65 -> 3
15, 21, 56, 62 -> 4
13, 36, 41, 64 -> 5
24, 32, 45, 53 -> 6

El código más corto gana y se aplican las lagunas estándar.

Python, 30

lambda a,b:a^b^7*(2<a*a*b%7<5)

Sin búsquedas, solo un poco de golpes.

Las caras opuestas vienen en pares que son complementos de tres bits entre sí, lo que significa que son XOR a 7.

1,6
2,5
3,4

Dadas dos caras de un conjunto, queremos obtener una cara del otro conjunto. Para (1,2,3), podemos hacer esto con XOR ( ^). Entonces, ^da la respuesta correcta hasta un complemento de tres bits, es decir x^7. Podemos complementar condicionalmente por x^7*_.

Para decidir si tomar o no el complemento (XOR con 7), verificamos si el triplete viola la regla de la derecha. Eso significa que a,bva en el orden cíclico inverso de

1,6
2,5
3,4

tratando cada línea como una de las tres categorías. Dado que los elementos en cada línea son negativos mod 7, podemos "hash" haciéndolos x*x%7.

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

Cada línea se obtiene de la forma cíclica anterior multiplicando por 4 módulo 7, por lo que podemos comprobar si esta relación se mantiene para (b,a)decidir si se complementan: a*a%7==b*b*4%7.

Esto es equivalente a verificar si el módulo 7 a**2 * b**(-2)es igual 4. Como b**6es igual al 1módulo 6, esto es equivalente a a**2 * b**4. Como el otro valor posible es 2 (verificando casos), podemos verificar si es 4 comparando con 3.

Hay un módulo buen polinomio de expresión 7 para el tercer lado dado dos lados una y b .

o factorizado

El módulo 7 se asigna a un resto en {0,1,2,3,4,5,6}.

Explico por qué funciona en esta respuesta de Math SE , aunque creo que probablemente haya un argumento más limpio que me estoy perdiendo. El único otro polinomio de dos términos que funciona es

que originalmente encontré al transformar mi bit-bashing en operaciones aritméticas, luego hice una búsqueda de fuerza bruta en polinomios de esta forma para encontrar el más agradable.

Por favor, siéntase libre de agregar puertos de esto a su idioma favorito; Esta es una publicación de CW.

J, 9 por Synthetica

7|3***+*-

Ver mi post

Dyalog APL, 9 por ngn (error tipográfico corregido por Adám)

7|3×××+×-

Escandalosamente robado de arriba J responde.

TI-Basic, 14 por Timtech

7fPart((A³B-AB³)/21

Pyth, 16 por FryAmTheEggman

M%*3-*H^G3*^H3G7

Define una función gde dos valores.

Golfscript, 18 por Peter Taylor (antiguo polinomio)

~1$*.5?3*@.*@*- 7%

CJam, 18 años por Martin Büttner (portado de Peter's GolfScript) (antiguo polinomio)

l~1$*_5#3*@_*@*m7%

Mathematica, 20 por Martin Büttner

Mod[+##(#-#2)3##,7]&

Sí, eso es un plus unario, y no, no hay una forma más corta que no use un plus unario.

dc, 21 por Toby Speight

sb7+d3^lb*rlb3^*-3*7%

Tengo que agregar 7 para aasegurar que la diferencia sea siempre positiva (DC tiene un %operador firmado ).

Julia, 24 23 por Martin Büttner

f(a,b)=3a*b*(a^2-b^2)%7

CoffeeScript, 28 26 por rink.attendant.6

x=(a,b)->3*a*b*(a*a-b*b)%7

JavaScript (ES6), 28 26 por rink.attendant.6

x=(a,b)=>3*a*b*(a*a-b*b)%7

Esencialmente lo mismo que CoffeeScript.

Python 28, por xnor

lambda a,b:3*a*b*(a*a-b*b)%7

Bash, 31

Nada especial:

echo $[3*($1**3*$2-$1*$2**3)%7]

o alternativamente:

echo $[3*$1*$2*($1*$1-$2*$2)%7]

Otro enfoque (más largo pero quizás interesante) .

Nim, 36 por Sillesta

proc(x,y:int):int=3*x*y*(x*x-y*y)%%7

Java 7, 46 44 por rink.attendant.6

int f(int a,int b){return(a*a-b*b)*a*b*3%7;}

Java 8, 25 23 por Kevin Cruijssen

a->b->(a*a-b*b)*a*b*3%7

PHP, 49 47 por rink.attendant.6

function x($a,$b){echo($a*$a-$b*$b)*3*$a*$b%7;}

Lote, 52 sin carne

set/aa=(3*(%1*%1*%1*%2-%1*%2*%2*%2)%%7+7)%%7
echo %a%

CMD no admite el módulo verdadero de forma nativa (por lo que no puede manejar números negativos), por lo tanto %%7+7)%%7.

MENOS (como una mezcla paramétrica ), 62 60 por rink.attendant.6

.x(@a,@b){@r:mod(3*@a*@b*(@a*@a-@b*@b),7);content:~"'@{r}'"}

Vea mi publicación a continuación .

05AB1E, 10 8 por Emigna (-2 bytes por Kevin Cruijssen)

nÆs`3P7%

Pruébalo en línea.

Haskell, _{31 27} 25 por nombre genérico para mostrar

a#b=3*a*b*(a*a-b*b)`mod`7

Pruébalo en línea!

Excel, 27 por Wernisch

=MOD(3*(A1^3*B1-A1*B1^3),7)

Excel VBA, 25 por Taylor Scott

?3*[A1^3*B1-A1*B1^3]Mod 7

Forth (gforth) 41 por reffu

: f 2>r 2r@ * 2r@ + 2r> - 3 * * * 7 mod ;

Pruébalo en línea!

C #, 23 por Kevin Cruijssen

a=>b=>(a*a-b*b)*a*b*3%7

CJam, 43 28 bytes

No tengo idea si un enfoque basado en una tabla completa será más corto, pero aquí va:

l_~^56213641532453s@S-#)g7*^

Entrada como

2 3

Salida:

1

Esta es una mezcla de mi algoritmo anterior para determinar la cara correcta de 2 caras y el enfoque de xors de xnor.

Pruébalo en línea aquí

MENOS, 62 bytes

Utiliza el algoritmo en esta publicación :

.x(@a,@b){@r:mod(3*@a*@b*(@a*@a+6*@b*@b),7);content:~"'@{r}'"}

Podría ser más corto si se usara el valor entero, pero para que se mostrara necesitaba usar la contentpropiedad CSS que requería interpolación variable .

¡Sin embargo, no es frecuente que se utilice un lenguaje de preprocesador CSS para golf de código!

Para usar con algo de HTML, harías esto:

p::after { .x(1, 3); }

<p>Number on top: </p>

Pyth, 30 bytes

K"23542 31463 12651 "h/x+K_Kz6

Requiere los dos dígitos como entrada, sin espacio en el medio (ej. 23No 2 3).

Explicación:

Cualquier secuencia de dos dígitos que se encuentre dentro 23542representa dos lados que tienen 1arriba. Del mismo modo, 31463para 2, etc. Invertir esta cadena da las secuencias para a 4través 6.

Este código solo realiza una búsqueda en la cadena "23542 31463 12651 15621 36413 24532", divide el índice entre 6 e incrementa para determinar cuál debe ser el lado superior.

Prueba en línea aquí.

Gracias a @FryAmTheEggman por los consejos para jugar al golf.

Adopta un enfoque similar al es1024 con una cadena de búsqueda diferente:

JavaScript (ES6), 73 72 61 bytes

t=(l,r)=>-~('354233146312651215623641332453'.search([l]+r)/5)

JavaScript (ES5), 88 87 77 bytes

function t(l,r){return -~('354233146312651215623641332453'.indexOf([l]+r)/5)}

CoffeeScript, 71 62 bytes

Y solo por diversión, el código es 1 byte más corto en CoffeeScript como ES6 debido a la omisión permitida de paréntesis

Debido al uso del -~truco, resultó ser el mismo número de caracteres que ES6.

t=(l,r)->-~('354233146312651215623641332453'.indexOf([l]+r)/5)

J (9)

Utiliza el algoritmo de esta publicación.

7|3***+*-

Gráfico de árbol de la función (podría aclarar algunas cosas):

    f=:7|3***+*-
    f
7 | 3 * * * + * -
   5 !: 4 < 'f'
  ┌─ 7            
  ├─ |            
──┤   ┌─ 3        
  │   ├─ *        
  └───┤   ┌─ *    
      │   ├─ *    
      └───┤   ┌─ +
          └───┼─ *
              └─ -

Demostración:

   3 f 5
1
   4 f 6
2
   2 f 6
3
   2 f 1
4
   1 f 2
3
   4 f 5
6

PHP, 81 bytes

Igual que mi solución de JavaScript:

function t($l,$r){echo(int)(1+strpos('354233146312651215623641332453',$l.$r)/5);}

Lua 118

Tuve que restaurar la última versión debido a un error que no puedo encontrar, ni tengo tiempo para buscarlo.

z=io.read;o={"","","34","5 2","2165","46 13",""," 31064","  5612","   2 5","    43"}a=z();b=z();print(o[a+b]:sub(a,a))

Sin embargo, todavía estoy trabajando en esto.

JavaScript (ES6), 79 bytes

No es el más corto, pero probé un enfoque diferente al actual en las respuestas.

f=(a,b)=>[a,b,7-a,7-b].reduce((p,v,i,r)=>p?p:'2312132'.indexOf([v]+r[i+1])+1,0)

Lua, 89 bytes

Un puerto sencillo de la solución Python de xnor.

x=require('bit32').bxor
function(a,b)c=a*a*b%7;return x(a,x(b,2<c and c<5 and 7 or 0))end

Bash, 85

Esto no compite en cuanto al golf con el polinomio mágico de @ xnor. Pero creo que esta es otra forma interesante de calcular la respuesta:

g(){
((d[$1$2]))||{
d[$1$2]=$3
g $2 $1 $[7-$3]
g $2 $3 $1
}
}
g 1 2 3
echo ${d[$1$2]}

Específicamente sabemos lo siguiente sobre dados:

• Si la cara izquierda es 1 y la cara derecha es 2, entonces la cara superior es 3
• La rotación alrededor de los vértices opuestos en 120 ° da más triples de valores faciales. Por ejemplo, rotamos {l = 1, r = 2, t = 3} una vez que obtenemos {l = 2, r = 3, t = 1} y girando nuevamente obtenemos {l = 3, r = 1, t = 2}
• La suma de caras opuestas es siempre 7

Combinando lo anterior de manera recursiva (usando {1,2,3} codificado como punto de partida), podemos generar el mapeo completo de {l, r} -> t para todos los valores posibles. Esta respuesta define una función recursiva g () que llena una matriz completa tal que d [lr] = t. La función recursiva se llama inicialmente con {1,2,3} y se repite en todo el cubo hasta que no haya más elementos de matriz que no se hayan establecido. La función se repite en sí misma de dos maneras:

• con l y r intercambiados yt restados de 7 (caras opuestas)
• con {l, r, t} girado a {r, t, l}

Luego realiza una simple búsqueda de matriz de los valores requeridos.

Dyalog APL , 9 bytes

Sustitución de caracteres descarados de la solución J de ɐɔıʇǝɥʇuʎs :

7|3×××+×-

Editar: más tarde me di cuenta de que esta solución exacta fue sugerida por ngn el 17 y 15 de enero.

  the division remainder when divided by seven of
  |        three times
  |        | the product of the arguments
  |        |   times   \┌───┐
  |        |     \  ┌───┤ × │
┌────┐   ┌────┐   ┌─┴─┐ └───┘ ┌───┐
│ 7| ├───┤ 3× ├───┤ × │   ┌───┤ + │ - the sum of the arguments
└────┘   └────┘   └─┬─┘ ┌─┴─┐ └───┘      
                    └───┤ × │ ---- times
                        └─┬─┘ ┌───┐
                          └───┤ - │ - the difference between the arguments
                              └───┘

TryAPL en línea!

Julia, 26 bytes

f(a,b)=a$b$7*(2<a^2*b%7<5)

o

f(a,b)=(3*a^5*b^5-a^3*b)%7

o

f(a,b)=3*a*b*(a+b)*(a-b)%7

Lisp común, 45 bytes

(lambda(a b)(mod(* 3 a b(-(* a a)(* b b)))7))

Pruébalo en línea!

Solución de puerto de xnor.

C # (compilador interactivo de Visual C #) , 49 bytes

x=>1+("3542331463126512156236413"+x).IndexOf(x)/5

Pruébalo en línea!

-1 byte gracias a @GB!

La entrada es una cadena de 2 caracteres que contiene los dígitos visibles izquierdo y derecho.

A continuación se muestra la solución que se me ocurrió de forma independiente. Aprovechando la cadena de búsqueda de la respuesta JavaScript de rink.attendant.6 , pude eliminar 5 bytes (pero ahora nuestras respuestas son bastante similares;)

C # (compilador interactivo de Visual C #) , 55 bytes

x=>1+"42354 31463 51265 21562 41364 24532".IndexOf(x)/6

Pruébalo en línea!