Escreva o programa ou a função que terá o valor esquerdo e direito dos dados como números inteiros (1-6) e retorne o valor por cima.

Layout de dados:

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

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

Então a entrada 6 4retornará 5.

A ordem é importante:

2 3 -> 1
3 2 -> 6

O programa não precisa trabalhar com valores de entrada inválidos.

Para desencorajar a abordagem óbvia (usando a tabela com todas as combinações), não é permitido o uso de qualquer codificação de texto incorporada ou rotinas de descompactação ou codificação de base ou qualquer outra coisa semelhante para reduzir o tamanho. Observe que o uso de tabela ainda é permitido e a rolagem de sua própria descompressão também é permitida, desde que isso não seja feito usando alguma função de biblioteca pronta.

Para fins de referência, aqui está uma tabela de todas as combinações (ou seja, todas as entradas e saídas possíveis):

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

O código mais curto vence e as brechas padrão se aplicam.

Python, 30

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

Nenhuma pesquisa, apenas um pouco contundente.

As faces opostas vêm em pares que são complementos de três bits, o que significa que eles são XOR a 7.

1,6
2,5
3,4

Dadas duas faces de um conjunto, queremos obter uma face do outro conjunto. Pois (1,2,3), podemos fazer isso com XOR ( ^). Então, ^dá a resposta certa até complemento de três bits, ou seja x^7. Podemos complementar condicionalmente por x^7*_.

Para decidir se deve ou não tomar o complemento (XOR com 7), verificamos se o trigêmeo viola a regra da mão direita. Isso significa que a,bocorre na ordem cíclica reversa de

1,6
2,5
3,4

tratando cada linha como uma das três categorias. Como os elementos em cada linha são negativos, mod 7, podemos "hash" fazendo isso x*x%7.

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

Cada linha é obtido a partir da ciclicamente anterior multiplicando por 4 modulo 7, para que possamos verificar se essa relação tem para (b,a)decidir se complementam: a*a%7==b*b*4%7.

Isso é equivalente a verificar se, módulo 7, a**2 * b**(-2)é igual 4. Como b**6é igual ao 1módulo 6, isso é equivalente a a**2 * b**4. Como o outro valor possível é 2 (verificando os casos), podemos verificar se é 4 comparando com 3.

Existe uma bela expressão polinomial módulo 7 para o terceiro lado, dado os dois lados a e b .

ou fatorado

O módulo 7 é mapeado para o restante em {0,1,2,3,4,5,6}.

Eu explico por que ele funciona nesta resposta do Math SE , embora eu ache que provavelmente exista um argumento mais claro que estou perdendo. O único outro polinômio de dois termos que funciona é

que eu originalmente encontrei ao transformar minha base de bits em operações aritméticas e, em seguida, fiz uma pesquisa de força bruta sobre polinômios dessa forma para encontrar a melhor.

Por favor, sinta-se à vontade para adicionar portos no seu idioma favorito; este é um post da CW.

J, 9 da Synthetica

7|3***+*-

Veja minha postagem

Dyalog APL, 9 por ngn (erro de digitação corrigido por Adám)

7|3×××+×-

Roubado descaradamente da resposta J acima.

TI-Basic, 14 da Timtech

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

Pyth, 16 por FryAmTheEggman

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

Define uma função gde dois valores.

Golfscript, 18 de Peter Taylor (polinômio antigo)

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

CJam, 18 anos, por Martin Büttner (portado de Peter's GolfScript) (antigo polinômio)

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

Mathematica, 20 por Martin Büttner

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

Sim, isso é um plus unário, e não, não há uma maneira mais curta que não use um plus unário.

dc, 21 por Toby Speight

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

Eu tenho que adicionar 7 para agarantir que a diferença seja sempre positiva (dc tem um %operador assinado ).

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

Essencialmente o mesmo que o 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]

ou alternativamente:

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

Outra abordagem (mais longa, mas talvez interessante) .

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 unclemeat

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

O CMD não suporta módulo verdadeiro de forma nativa (portanto, não pode lidar com números negativos) - portanto %%7+7)%%7.

MENOS (como um mixin paramétrico ), 62 60 por rink.attendant.6

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

Veja meu post abaixo .

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

nÆs`3P7%

Experimente online.

Haskell, _{31 27} 25 por nome de exibição genérico

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

Experimente online!

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 ;

Experimente online!

C #, 23 por Kevin Cruijssen

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

CJam, 43 28 bytes

Não faço ideia se uma abordagem baseada em tabela completa será mais curta, mas aqui vai:

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

Entrada como

2 3

Resultado:

1

Esta é uma mistura do meu algoritmo anterior para determinar a face correta de 2 faces e a abordagem de xors do xnor.

Experimente online aqui

MENOS, 62 bytes

Usa o algoritmo neste post :

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

Poderia ser mais curto se o valor inteiro fosse usado, mas para exibi-lo eu precisava usar a contentpropriedade CSS que exigia interpolação de variável .

No entanto, não é sempre que uma linguagem de pré-processador CSS é usada para o código de golfe!

Para usar um pouco de HTML, faça o seguinte:

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

<p>Number on top: </p>

Pitão, 30 bytes

K"23542 31463 12651 "h/x+K_Kz6

Requer os dois dígitos como entrada, sem espaço no meio (ex. 23Não 2 3).

Explicação:

Qualquer sequência de dois dígitos que esteja dentro 23542representa dois lados que estão 1no topo. Da mesma forma, 31463para 2, etc. A reversão dessa string fornece as sequências para 4through 6.

Esse código apenas faz uma pesquisa na string "23542 31463 12651 15621 36413 24532", divide o índice por 6 e incrementa para determinar qual deve ser o lado superior.

Teste online aqui.

Obrigado a @FryAmTheEggman por dicas de golfe.

Adota uma abordagem semelhante à es1024 com uma sequência de pesquisa 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

E apenas por diversão, o código é 1 byte menor no CoffeeScript como ES6 devido à omissão permitida de parênteses

Devido ao uso do -~truque, esse acabou sendo o mesmo número de caracteres que o ES6.

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

J (9)

Usa o algoritmo desta postagem.

7|3***+*-

Gráfico em árvore da função (pode esclarecer algumas coisas):

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

Demonstração:

   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 à minha solução JavaScript:

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

Lua 118

Tive que restaurar a última versão por causa de um bug que não consigo encontrar, nem ter tempo para procurá-lo.

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

Ainda estou trabalhando nisso.

JavaScript (ES6), 79 bytes

Não é o mais curto, mas tentei uma abordagem diferente da que está atualmente nas respostas.

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

Uma porta direta da solução Python da 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

Isso não compete em termos de golfe com o polinômio mágico do @ xnor. Mas acho que essa é outra maneira interessante de calcular a resposta:

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

Especificamente, sabemos o seguinte sobre dados:

• Se a face esquerda for 1 e a face direita for 2, a face superior será 3
• A rotação em torno dos vértices opostos em 120 ° fornece mais triplos de valores de face. Por exemplo, giramos {l = 1, r = 2, t = 3} quando obtemos {l = 2, r = 3, t = 1} e girando novamente, obtemos {l = 3, r = 1, t = 2}
• A soma das faces opostas é sempre 7

Combinando o exposto acima recursivamente (usando {1,2,3} codificado como ponto de partida), podemos gerar todo o mapeamento de {l, r} -> t para todos os valores possíveis. Esta resposta define uma função recursiva g () que preenche uma matriz completa, de modo que d [lr] = t. A função recursiva é chamada inicialmente com {1,2,3} e se repete em todo o cubo até que não haja mais elementos da matriz que não foram configurados. A função se repete de duas maneiras:

• com l er trocados et subtraído de 7 (faces opostas)
• com {l, r, t} girado para {r, t, l}

Em seguida, ele faz uma pesquisa simples na matriz dos valores necessários.

Dyalog APL , 9 bytes

Substituição flagrante de caracteres da solução J de ɐɔıʇǝɥʇuʎs :

7|3×××+×-

Edit: Mais tarde notei que esta solução exata foi sugerida por ngn em 17 de janeiro de 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
                              └───┘

TryAPL online!

Julia, 26 bytes

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

Lisp comum, 45 bytes

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

Experimente online!

Porta da solução xnor.

C # (compilador interativo do Visual C #) , 49 bytes

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

Experimente online!

-1 byte graças a @GB!

A entrada é uma sequência de 2 caracteres que contém os dígitos esquerdo e direito visíveis.

Abaixo está a solução que eu criei de forma independente. Aproveitando a string de pesquisa da resposta JavaScript de rink.attendant.6, consegui reduzir 5 bytes (mas agora nossas respostas são bem parecidas;)

C # (compilador interativo do Visual C #) , 55 bytes

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

Experimente online!