Ecrivez un programme ou une fonction qui prendra les valeurs gauche et droite de dés sous forme d’entiers (1-6) et renverra la valeur par dessus.

Disposition des dés:

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

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

Donc, la saisie 6 4va revenir 5.

L'ordre est important:

2 3 -> 1
3 2 -> 6

Le programme n'a pas à travailler avec des valeurs d'entrée non valides.

Pour décourager une approche évidente (utilisation de table avec toutes les combinaisons), il est interdit d’utiliser un codage de texte intégré, des routines de dé / compression, un codage de base ou tout autre moyen similaire permettant de réduire la taille. Notez que l'utilisation de table est toujours autorisée et que votre propre décompression est autorisée, aussi longtemps que cela n'est pas fait en utilisant une fonction de bibliothèque prête.

À titre de référence, voici un tableau de toutes les combinaisons (c.-à-d. Toutes les entrées et sorties possibles):

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

Le code le plus court l'emporte et les échappatoires standard s'appliquent.

Python, 30

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

Aucune recherche, juste un peu bashing.

Les faces opposées sont des paires qui se complètent en trois bits, ce qui signifie qu'elles sont XOR à 7.

1,6
2,5
3,4

Étant donné deux visages d'un ensemble, nous voulons obtenir un visage de l'autre ensemble. Pour (1,2,3), nous pouvons le faire avec XOR ( ^). Donc, ^donne la bonne réponse jusqu'à un complément de trois bits, ce qui signifie x^7. Nous pouvons compléter conditionnellement par x^7*_.

Pour décider de prendre ou non le complément (XOR avec 7), nous vérifions si le triplet enfreint la règle de la main droite. Cela signifie que cela a,bva dans l'ordre cyclique inverse de

1,6
2,5
3,4

traiter chaque ligne comme l'une des trois catégories. Comme les éléments de chaque ligne sont des négatifs mod 7, nous pouvons les "hacher" en les faisant x*x%7.

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

Chaque ligne est obtenue à partir de la manière cyclique précédente en multipliant par 4 modulo 7, afin que nous puissions vérifier si cette relation est valable pour (b,a)décider si vous souhaitez compléter: a*a%7==b*b*4%7.

Cela revient à vérifier si, modulo 7, a**2 * b**(-2)est égal à 4. Puisque b**6égal à 1modulo 6, cela équivaut à a**2 * b**4. Comme l'autre valeur possible est 2 (en cochant les cas), nous pouvons vérifier si c'est 4 en comparant à 3.

Il y a une belle expression polynomiale modulo 7 pour le troisième côté étant donné les deux côtés a et b .

ou factorisé

Le modulo 7 correspond à un reste dans {0,1,2,3,4,5,6}.

J'explique pourquoi cela fonctionne dans cette réponse de Math SE , bien que je pense qu'il y a probablement un argument plus clair qui me manque. Le seul autre polynôme à deux termes qui fonctionne est

que j’ai trouvé à l’origine en transformant mon bit-bashing en opérations arithmétiques, puis a effectué une recherche brute-force sur des polynômes de cette forme afin de trouver la plus jolie.

N'hésitez pas à ajouter des ports de cela dans votre langue préférée; c'est un post CW.

J, 9 de Synthetica

7|3***+*-

Voir mon post

Dyalog APL, 9 de ngn (typo corrigée par Adám)

7|3×××+×-

Vol flagrant d'en haut J réponse.

TI-Basic, 14 de Timtech

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

Pyth, 16 par FryAmTheEggman

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

Définit une fonction gde deux valeurs.

Golfscript, 18 de Peter Taylor (ancien polynôme)

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

CJam, 18 ans de Martin Büttner (importé de Peter's GolfScript) (ancien polynôme)

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

Mathematica, 20 ans par Martin Büttner

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

Oui, c'est un plus unaire, et non, il n'y a pas de moyen plus court qui n'utilise pas de plus unaire.

dc, 21 par Toby Speight

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

Je dois ajouter 7 à apour que la différence soit toujours positive (dc a un %opérateur signé ).

Julia, 24 23 de Martin Büttner

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

CoffeeScript, 28 26 de rink.attendant.6

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

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

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

Essentiellement identique à CoffeeScript.

Python 28, par xnor

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

Bash, 31 ans

Rien de spécial:

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

Ou bien:

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

Une autre approche (plus longue mais peut-être intéressante) .

Nim, 36 de Sillesta

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

Java 7, 46 44 de rink.attendant.6

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

Java 8, 25 23 de Kevin Cruijssen

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

PHP, 49 47 par rink.attendant.6

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

Lot, 52 non-traité

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

CMD ne supporte pas le vrai module en natif (donc ne peut pas gérer les nombres négatifs) - par conséquent %%7+7)%%7.

LESS (en tant que mixin paramétrique ), 62 60 par rink.attendant.6

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

Voir mon post ci-dessous .

05AB1E, 10 8 de Emigna (-2 octets de Kevin Cruijssen)

nÆs`3P7%

Essayez-le en ligne.

Haskell, _{31 27} 25 par nom d'affichage générique

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

Essayez-le en ligne!

Excel, 27 par de Wernisch

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

Excel VBA, 25 par Taylor Scott

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

Forth (gforth) 41 par reffu

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

Essayez-le en ligne!

C #, 23 de Kevin Cruijssen

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

CJam, 43 28 octets

Aucune idée si une approche basée sur une table complète sera plus courte, mais voici:

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

Entrée comme

2 3

Sortie:

1

Ceci est un mélange de mon algorithme précédent pour déterminer le bon visage sur 2 faces et l'approche de xors par xnor.

Essayez-le en ligne ici

MOINS, 62 octets

Utilise l'algorithme dans ce post :

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

Il pourrait être plus court si la valeur entière était utilisée, mais pour l'afficher, il fallait utiliser la contentpropriété CSS qui nécessitait une interpolation de variable .

Néanmoins, il est rare qu'un langage de préprocesseur CSS soit utilisé pour le code golf!

Pour utiliser avec du HTML, vous feriez ceci:

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

<p>Number on top: </p>

Pyth, 30 octets

K"23542 31463 12651 "h/x+K_Kz6

Nécessite les deux chiffres en entrée, sans espace entre eux (ex. 23 Non 2 3).

Explication:

Toute séquence de deux chiffres située à l'intérieur 23542représente deux côtés qui se trouvent 1en haut. De même, 31463pour 2, etc. Inverser cette chaîne donne les séquences pour4 transmises 6.

Ce code ne fait qu'une recherche dans la chaîne "23542 31463 12651 15621 36413 24532" , divise l'index par 6 et s'incrémente pour déterminer ce que le côté supérieur doit être.

Testez en ligne ici.

Merci à @FryAmTheEggman pour ses conseils sur le golf.

Prend une approche similaire à celle es1024 avec une chaîne de recherche différente:

JavaScript (ES6), 73 72 61 octets

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

JavaScript (ES5), 88 87 77 octets

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

CoffeeScript, 71 62 octets

Et juste pour le plaisir, le code est plus court d'un octet dans CoffeeScript que ES6 en raison de l'omission autorisée des parenthèses

En raison de l'utilisation de l' -~astuce, cela s'est avéré être le même nombre de caractères que ES6.

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

J (9)

Utilise l'algorithme de ce post.

7|3***+*-

Graphique en arborescence de la fonction (peut clarifier certaines choses):

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

Manifestation:

   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 octets

Identique à ma solution JavaScript:

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

Lua 118

J'ai dû restaurer la dernière version à cause d'un bogue que je ne pouvais pas trouver, ni avoir le temps de le chercher.

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

Je travaille toujours là-dessus.

JavaScript (ES6), 79 octets

Pas le plus court mais j'ai essayé une approche différente de celle utilisée actuellement dans les réponses.

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 octets

Un port simple de la solution 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

Cela ne concurrence pas le golf avec le polynôme magique de @ xnor. Mais je pense que ceci est un autre moyen intéressant de calculer la réponse:

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

Plus précisément, nous connaissons les points suivants concernant les dés:

• Si la face gauche est 1 et la face droite est 2, alors la face supérieure est 3
• La rotation de 120 ° autour des sommets opposés donne quelques triples plus de valeurs faciales. Par exemple, nous effectuons une rotation {l = 1, r = 2, t = 3} une fois que nous obtenons {l = 2, r = 3, t = 1} et une nouvelle rotation donne {l = 3, r = 1, t = 2}
• La somme des faces opposées est toujours 7

En combinant ce qui précède de manière récursive (en utilisant {1,2,3} codé en dur comme point de départ), nous pouvons générer le mappage complet de {l, r} -> t pour toutes les valeurs possibles. Cette réponse définit une fonction récursive g () qui remplit un tableau complet tel que d [lr] = t. La fonction récursive est initialement appelée avec {1, 2, 3} et est récurrente dans tout le cube jusqu'à ce qu'il n'y ait plus d'éléments de tableau non définis. La fonction revient à elle-même de deux manières:

• avec l et r échangés et soustraits de 7 (faces opposées)
• avec {l, r, t} tourné à {r, t, l}

Il effectue ensuite une simple recherche de tableau des valeurs requises.

Dyalog APL , 9 octets

Substitution flagrante de caractères de la solution J de ɐɔıʇǝɥʇuʎs :

7|3×××+×-

Edit: Plus tard, j'ai remarqué que cette solution exacte avait été suggérée par ngn les 17 et 15 janvier.

  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 ligne!

Julia, 26 octets

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

ou

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

ou

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

Common Lisp, 45 octets

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

Essayez-le en ligne!

Port de la solution xnor.

C # (compilateur interactif Visual C #) , 49 octets

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

Essayez-le en ligne!

-1 octet grâce à @GB!

L'entrée est une chaîne de 2 caractères contenant les chiffres visibles de gauche et de droite.

Vous trouverez ci-dessous la solution que j'ai proposée indépendamment. En exploitant la chaîne de recherche de la réponse JavaScript de rink.attendant.6 , j'ai pu supprimer 5 octets (mais à présent, nos réponses sont assez similaires;)

C # (compilateur interactif Visual C #) , 55 octets

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

Essayez-le en ligne!