Schreiben Sie ein Programm oder eine Funktion, die den linken und rechten Wert der Würfel als ganze Zahlen (1-6) nimmt und den Wert oben zurückgibt.

Würfellayout:

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

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

Die Eingabe 6 4kehrt also zurück 5.

Ordnung ist wichtig:

2 3 -> 1
3 2 -> 6

Das Programm muss nicht mit ungültigen Eingabewerten arbeiten.

Um einen offensichtlichen Ansatz zu vermeiden (Verwendung einer Tabelle mit allen Kombinationen), ist die Verwendung von integrierten Textcodierungs- oder Dekomprimierungsroutinen oder einer Basiscodierung oder Ähnlichem zur Reduzierung der Größe nicht zulässig. Beachten Sie, dass die Verwendung von table weiterhin zulässig ist und auch das Rolling Ihrer eigenen Dekomprimierung zulässig ist, solange keine fertige Bibliotheksfunktion verwendet wird.

Zu Referenzzwecken finden Sie hier eine Tabelle aller Kombinationen (dh aller möglichen Ein- und Ausgänge):

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

Kürzester Code gewinnt, und es gelten Standardlücken.

Python, 30

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

Keine Suchanfragen, nur ein bisschen hämmern.

Die gegenüberliegenden Flächen werden paarweise als Drei-Bit-Komplemente dargestellt, was bedeutet, dass sie mit 7 XOR verknüpft sind.

1,6
2,5
3,4

Bei zwei Gesichtern aus einem Satz möchten wir ein Gesicht aus dem anderen Satz erhalten. Für (1,2,3)können wir dies mit XOR ( ^) tun . So ^gibt die richtige Antwort bis zu drei-Bit - Komplement, was bedeutet x^7. Wir können bedingt ergänzen durch x^7*_.

Um zu entscheiden, ob das Komplement genommen werden soll oder nicht (XOR mit 7), prüfen wir, ob das Triplett gegen die Rechtsregel verstößt. Das heißt, das a,bgeht in der umgekehrten zyklischen Reihenfolge von

1,6
2,5
3,4

Behandlung jeder Zeile als eine der drei Kategorien. Da die Elemente in jeder Zeile Negative Mod 7 sind, können wir sie "hashen", indem wir dies tun x*x%7.

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

Jede Zeile wird von den zyklisch vorherigen erhalten von 7 um 4 Modulo multipliziert, so können wir prüfen , ob diese Beziehung für hält , (b,a)um zu entscheiden , ob ergänzen: a*a%7==b*b*4%7.

Dies entspricht der Überprüfung, ob modulo 7 a**2 * b**(-2)gleich ist 4. Da b**6gleich 1Modulo 6 ist, ist dies äquivalent zu a**2 * b**4. Da der andere mögliche Wert 2 ist (durch Überprüfen von Fällen), können wir durch Vergleichen mit 3 prüfen, ob es 4 ist.

Für die dritte Seite gibt es einen schönen Polynomausdruck modulo 7 mit zwei Seiten a und b .

oder faktorisiert

Das Modulo 7 bildet einen Rest in {0,1,2,3,4,5,6} ab.

Ich erkläre, warum es in dieser Math SE-Antwort funktioniert , obwohl ich denke, dass es wahrscheinlich ein saubereres Argument gibt, das mir fehlt. Das einzige andere Zwei-Term-Polynom, das funktioniert, ist

Das habe ich ursprünglich gefunden, indem ich mein Bit-Bashing in arithmetische Operationen umgewandelt habe. Dann habe ich eine Brute-Force-Suche über Polynome dieser Form durchgeführt, um das schönere zu finden.

Bitte fügen Sie diese Ports in Ihre bevorzugte Sprache ein. Dies ist ein CW-Beitrag.

J, 9 von Synthetica

7|3***+*-

Siehe meinen Beitrag

Dyalog APL, 9 von ngn (Tippfehler behoben von Adám)

7|3×××+×-

Offen gestohlen von oben J Antwort.

TI-Basic, 14 von Timtech

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

Pyth, 16 von FryAmTheEggman

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

Definiert eine Funktion gaus zwei Werten.

Golfscript, 18 von Peter Taylor (altes Polynom)

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

CJam, 18 von Martin Büttner (portiert aus Peters GolfScript) (altes Polynom)

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

Mathematica, 20 von Martin Büttner

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

Ja, das ist ein unäres Plus, und nein, es gibt keinen kürzeren Weg, der kein unäres Plus verwendet.

dc, 21 von Toby Speight

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

Ich muss 7 addieren, aum sicherzustellen, dass die Differenz immer positiv ist (dc hat einen vorzeichenbehafteten %Operator).

Julia, 24 23 von Martin Büttner

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

CoffeeScript, 28 26 von rink.attendant.6

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

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

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

Im Wesentlichen dasselbe wie CoffeeScript.

Python 28 von xnor

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

Bash, 31

Nichts Besonderes:

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

oder alternativ:

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

Ein weiterer (längerer, aber vielleicht interessanter) Ansatz .

Nim, 36 von Sillesta

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

Java 7, 46 44 von rink.attendant.6

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

Java 8, 25 23 von Kevin Cruijssen

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

PHP, 49 47 von rink.attendant.6

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

Batch, 52 Unclemeat

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

CMD unterstützt den wahren Modul nativ nicht (kann also keine negativen Zahlen verarbeiten) - daher %%7+7)%%7.

LESS (als parametrisches Mixin ), 62 60 von rink.attendant.6

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

Siehe meinen Beitrag unten .

05AB1E, 10 8 von Emigna (-2 Bytes von Kevin Cruijssen)

nÆs`3P7%

Probieren Sie es online aus.

Haskell, _{31 27} 25 nach generischem Anzeigenamen

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

Probieren Sie es online!

Excel, 27 von von Wernisch

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

Excel VBA, 25 von Taylor Scott

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

Forth (gforth) 41 von reffu

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

Probieren Sie es online!

C #, 23 von Kevin Cruijssen

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

CJam, 43 28 Bytes

Keine Ahnung, ob ein vollständiger tabellenbasierter Ansatz kürzer sein wird, aber hier ist:

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

Eingabe wie

2 3

Ausgabe:

1

Dies ist eine Mischung aus meinem vorherigen Algorithmus, um das richtige Gesicht aus 2 Gesichtern und xnors Annäherung an xors zu bestimmen.

Probieren Sie es hier online aus

WENIGER, 62 Bytes

Verwendet den Algorithmus in diesem Beitrag :

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

Es könnte kürzer sein, wenn der ganzzahlige Wert verwendet wurde, aber um ihn anzuzeigen, musste ich die CSS- contentEigenschaft verwenden, die eine Variableninterpolation erforderte .

Nichtsdestotrotz wird beim Code-Golf nicht oft eine CSS-Präprozessorsprache verwendet!

So verwenden Sie HTML:

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

<p>Number on top: </p>

Pyth, 30 Bytes

K"23542 31463 12651 "h/x+K_Kz6

Benötigt die zwei Ziffern als Eingabe ohne Leerzeichen dazwischen (z. B. 23nicht 2 3).

Erläuterung:

Jede zweistellige Sequenz, die innerhalb liegt, 23542repräsentiert zwei Seiten, die 1oben liegen. Ebenso 31463für 2 usw. Wenn Sie diese Zeichenfolge umkehren, erhalten Sie die Sequenzen für 4through 6.

Dieser Code führt lediglich eine Suche in der Zeichenfolge durch "23542 31463 12651 15621 36413 24532", teilt den Index durch 6 und erhöht ihn, um zu bestimmen, wie hoch die Oberseite sein muss.

Hier online testen.

Vielen Dank an @FryAmTheEggman für die Tipps zum Golfen.

Verfolgt einen ähnlichen Ansatz wie es1024 mit einer anderen Suchzeichenfolge:

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

Aus Spaß ist der Code in CoffeeScript um 1 Byte kürzer als in ES6, da keine Klammern angegeben werden dürfen

Aufgrund der Verwendung des -~Tricks stellte sich heraus, dass dies die gleiche Anzahl von Zeichen wie ES6 ist.

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

J (9)

Verwendet den Algorithmus aus diesem Beitrag.

7|3***+*-

Baumdiagramm der Funktion (könnte einige Dinge aufklären):

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

Demonstration:

   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

Wie meine JavaScript-Lösung:

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

Lua 118

Musste die letzte Version aufgrund eines Fehlers wiederherstellen, den ich nicht finden kann, und hatte auch keine Zeit, danach zu suchen.

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

Ich arbeite aber immer noch daran.

JavaScript (ES6), 79 Byte

Nicht die kürzeste, aber ich habe versucht, einen anderen Ansatz als derzeit in den Antworten.

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

Eine unkomplizierte Portierung der Python-Lösung von 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

Dies konkurriert nicht mit dem magischen Polynom von @ xnor. Aber ich denke, das ist eine andere interessante Methode, um die Antwort zu berechnen:

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

Konkret kennen wir uns mit Würfeln aus:

• Wenn die linke Seite 1 und die rechte Seite 2 ist, ist die obere Seite 3
• Eine Drehung um 120 ° um die gegenüberliegenden Scheitelpunkte ergibt weitere Dreifachwerte. ZB rotieren wir {l = 1, r = 2, t = 3}, sobald wir {l = 2, r = 3, t = 1} erhalten, und rotieren wir erneut, erhalten wir {l = 3, r = 1, t = 2}.
• Die Summe der gegenüberliegenden Flächen ist immer 7

Durch rekursives Kombinieren der obigen Werte (unter Verwendung von {1,2,3} als Ausgangspunkt) können wir die gesamte Abbildung von {l, r} -> t für alle möglichen Werte generieren. Diese Antwort definiert eine rekursive Funktion g (), die ein vollständiges Array mit d [lr] = t auffüllt. Die rekursive Funktion wird anfänglich mit {1,2,3} aufgerufen und durchläuft den gesamten Cube, bis keine Array-Elemente mehr festgelegt wurden. Die Funktion rekursiert auf zwei Arten in sich selbst:

• mit l und r vertauscht und t von 7 subtrahiert (gegenüberliegende Flächen)
• mit {l, r, t} gedreht zu {r, t, l}

Anschließend wird eine einfache Array-Suche der erforderlichen Werte durchgeführt.

Dyalog APL , 9 Bytes

Offensichtliche Zeichensubstitution der J-Lösung von ɐɔıʎuʇǝɥʇs :

7|3×××+×-

Edit: Ich habe später bemerkt, dass diese genaue Lösung von ngn am 17. Januar, 15 vorgeschlagen wurde.

  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)

oder

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

oder

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

Common Lisp, 45 Bytes

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

Probieren Sie es online!

Port der xnor-Lösung.

C # (Visual C # Interactive Compiler) , 49 Byte

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

Probieren Sie es online!

-1 Byte dank @GB!

Die Eingabe ist eine 2-stellige Zeichenfolge, die die sichtbaren linken und rechten Ziffern enthält.

Unten ist die Lösung, die ich selbstständig gefunden habe. Mithilfe der Suchzeichenfolge aus der JavaScript-Antwort von rink.attendant.6 konnte ich 5 Bytes sparen (aber jetzt sind unsere Antworten ziemlich ähnlich;)

C # (Visual C # Interactive Compiler) , 55 Byte

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

Probieren Sie es online!