Scrivi il programma o la funzione che prenderà il valore destro e sinistro dei dadi come numeri interi (1-6) e restituirà il valore in alto.

Disposizione dei dadi:

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

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

Quindi l'inserimento 6 4tornerà 5.

L'ordine è importante:

2 3 -> 1
3 2 -> 6

Il programma non deve funzionare con valori di input non validi.

Per scoraggiare l'approccio ovvio (utilizzando la tabella con tutte le combinazioni), non è consentito utilizzare qualsiasi codifica di testo incorporata o routine di de / compressione o codifica di base o qualsiasi altra cosa simile per ridurre le dimensioni. Si noti che l'utilizzo di table è ancora consentito e che è consentito anche il rollback della propria decompressione, purché non venga eseguita utilizzando alcune funzioni di libreria ready.

A scopo di riferimento, ecco una tabella di tutte le combinazioni (ovvero tutti gli ingressi e le uscite possibili):

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

Il codice più corto vince e si applicano scappatoie standard.

Python, 30

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

Nessuna ricerca, basta colpire un po '.

Le facce opposte si presentano in coppie che sono complementari a tre bit l'una dell'altra, il che significa che XOR a 7.

1,6
2,5
3,4

Dati due volti da un set, vogliamo ottenere un viso dall'altro set. Per (1,2,3), possiamo farlo con XOR ( ^). Quindi, ^dà la risposta giusta fino a un complemento a tre bit, il che significa x^7. Possiamo integrare condizionatamente di x^7*_.

Per decidere se prendere o meno il complemento (XOR con 7), controlliamo se la tripletta viola la regola della mano destra. Ciò significa che a,bva nell'ordine ciclico inverso di

1,6
2,5
3,4

trattando ogni riga come una delle tre categorie. Poiché gli elementi in ogni riga sono negativi mod 7, possiamo "cancellarli" facendo x*x%7.

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

Ogni linea è ottenuta dalla precedente ciclicamente moltiplicando per 4 modulo 7, in modo che possiamo verificare se questo rapporto vale per (b,a)decidere se integrare: a*a%7==b*b*4%7.

Ciò equivale a verificare se, modulo 7, è a**2 * b**(-2)uguale 4. Poiché è b**6uguale a 1modulo 6, questo equivale a a**2 * b**4. Poiché l'altro valore possibile è 2 (controllando i casi), possiamo verificare se è 4 confrontandolo con 3.

Esiste una bella espressione polinomiale modulo 7 per il terzo lato dato due lati a e b .

o fattorizzato

Il modulo 7 è mappato ad un resto in {0,1,2,3,4,5,6}.

Spiego perché funziona in questa risposta di Math SE , anche se penso che probabilmente manchi un argomento più pulito. L'unico altro polinomio a due termini che funziona è

che originariamente ho trovato trasformando il mio bit-bashing in operazioni aritmetiche, quindi ho fatto una ricerca di forza bruta sui polinomi di questa forma per trovare quella più bella.

Non esitate a aggiungere porte di questo nella tua lingua preferita; questo è un post in CW.

J, 9 di Synthetica

7|3***+*-

Vedi il mio post

Dyalog APL, 9 di ngn (refuso da Adám)

7|3×××+×-

Sfacciatamente rubato dall'alto J risposta.

TI-Basic, 14 di Timtech

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

Pyth, 16 di FryAmTheEggman

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

Definisce una funzione gdi due valori.

Golfscript, 18 di Peter Taylor (vecchio polinomio)

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

CJam, 18 di Martin Büttner (portato da Peter's GolfScript) (vecchio polinomio)

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

Mathematica, 20 anni di Martin Büttner

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

Sì, questo è un vantaggio unario e no, non esiste un modo più breve che non utilizza un vantaggio unario.

dc, 21 di Toby Speight

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

Devo aggiungere 7 per aassicurarsi che la differenza sia sempre positiva (dc ha un %operatore firmato ).

Julia, 24 23 di Martin Büttner

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

CoffeeScript, 28 26 di rink.attendant.6

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

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

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

Sostanzialmente uguale a CoffeeScript.

Python 28, di xnor

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

Bash, 31

Niente di speciale:

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

o in alternativa:

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

Un altro approccio (più lungo ma forse interessante) .

Nim, 36 di Sillesta

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

Java 7, 46 44 di rink.attendant.6

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

Java 8, 25 23 di Kevin Cruijssen

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

PHP, 49 47 di rink.attendant.6

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

Lotto, 52 Unlemeat

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

CMD non supporta il vero modulo in modo nativo (quindi non può gestire numeri negativi) - quindi %%7+7)%%7.

MENO (come mixin parametrico ), 62 60 di rink.attendant.6

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

Vedi il mio post qui sotto .

05AB1E, 10 8 di Emigna (-2 byte di Kevin Cruijssen)

nÆs`3P7%

Provalo online.

Haskell, _{31 27} 25 per nome visualizzato generico

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

Provalo online!

Excel, 27 di Wernisch

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

Excel VBA, 25 di Taylor Scott

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

Forth (gforth) 41 di reffu

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

Provalo online!

C #, 23 di Kevin Cruijssen

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

CJam, 43 28 byte

Non ho idea se un approccio basato su una tabella completa sarà più breve, ma ecco qui:

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

Inserisci come

2 3

Produzione:

1

Questa è una miscela del mio algoritmo precedente per determinare la faccia corretta da 2 facce e l'approccio di xor di xnor.

Provalo online qui

MENO, 62 byte

Utilizza l'algoritmo in questo post :

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

Potrebbe essere più breve se fosse utilizzato il valore intero, ma per visualizzarlo avevo bisogno di usare la contentproprietà CSS che richiedeva l' interpolazione variabile .

Tuttavia, non è spesso un linguaggio preprocessore CSS utilizzato per il golf del codice!

Per utilizzare con un po 'di HTML, devi fare questo:

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

<p>Number on top: </p>

Pyth, 30 byte

K"23542 31463 12651 "h/x+K_Kz6

Richiede le due cifre come input, senza spazio in mezzo (es. 23Non 2 3).

Spiegazione:

Qualsiasi sequenza di due cifre che si trova all'interno 23542rappresenta due lati che hanno 1in cima. Allo stesso modo, 31463per 2, ecc. L'inversione di questa stringa fornisce le sequenze per 4through 6.

Questo codice esegue solo una ricerca nella stringa "23542 31463 12651 15621 36413 24532", divide l'indice per 6 e incrementa per determinare quale deve essere il lato superiore.

Test online qui.

Grazie a @FryAmTheEggman per suggerimenti su come giocare a golf.

Adotta un approccio simile a es1024 con una stringa di ricerca diversa:

JavaScript (ES6), 73 72 61 byte

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

JavaScript (ES5), 88 87 77 byte

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

CoffeeScript, 71 62 byte

E solo per divertimento, il codice è più breve di 1 byte in CoffeeScript come ES6 a causa dell'omissione consentita tra parentesi

A causa dell'uso del -~trucco, questo si è rivelato essere lo stesso numero di personaggi di ES6.

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

J (9)

Utilizza l'algoritmo di questo post.

7|3***+*-

Grafico ad albero della funzione (potrebbe chiarire alcune cose):

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

Dimostrazione:

   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 byte

Come la mia soluzione JavaScript:

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

Lua 118

Ho dovuto ripristinare l'ultima versione a causa di un bug che non riesco a trovare, né ho tempo di cercarlo.

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))

Ci sto ancora lavorando.

JavaScript (ES6), 79 byte

Non il più breve ma ho provato un approccio diverso da quello attualmente nelle risposte.

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 byte

Una porta semplice della soluzione Python di 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

Questo non compete al golf con il polinomio magico di @xnor. Ma penso che questo sia un altro modo interessante per calcolare la risposta:

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

Nello specifico sappiamo quanto segue sui dadi:

• Se la faccia sinistra è 1 e la faccia destra è 2, la faccia superiore è 3
• La rotazione attorno ai vertici opposti di 120 ° fornisce alcune triple di valori facciali. Ad esempio, ruotiamo {l = 1, r = 2, t = 3} una volta che otteniamo {l = 2, r = 3, t = 1} e ruotando di nuovo otteniamo {l = 3, r = 1, t = 2}
• La somma delle facce opposte è sempre 7

Combinando ricorsivamente quanto sopra (usando {1,2,3} hardcoded come punto di partenza), possiamo generare l'intero mapping di {l, r} -> t per tutti i possibili valori. Questa risposta definisce una funzione ricorsiva g () che popola un array completo tale che d [lr] = t. La funzione ricorsiva viene inizialmente chiamata con {1,2,3} e ricorre in tutto il cubo fino a quando non ci sono più elementi dell'array che non sono stati impostati. La funzione ricorre in se stessa in due modi:

• con L e R scambiate et sottratte da 7 (facce opposte)
• con {l, r, t} ruotato su {r, t, l}

Quindi esegue una semplice ricerca di array dei valori richiesti.

Dyalog APL , 9 byte

Sostituzione palese dei caratteri della soluzione J di ɐɔıʇǝɥʇuʎs :

7|3×××+×-

Modifica: In seguito ho notato che questa soluzione esatta è stata suggerita da ngn il 17 gennaio 15.

  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
                              └───┘

ProvaAPL online!

Julia, 26 byte

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 comune, 45 byte

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

Provalo online!

Porta della soluzione xnor.

C # (compilatore interattivo Visual C #) , 49 byte

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

Provalo online!

-1 byte grazie a @GB!

L'input è una stringa di 2 caratteri contenente le cifre sinistra e destra visibili.

Di seguito è la soluzione che ho trovato in modo indipendente. Sfruttando la stringa di ricerca dalla risposta JavaScript di rink.attendant.6 , sono stato in grado di radere 5 byte (ma ora le nostre risposte sono abbastanza simili;)

C # (compilatore interattivo Visual C #) , 55 byte

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

Provalo online!