Einführung:

Ein 3x3x3 Rubik's Cube hat mögliche Permutationen, was ungefähr 43 Trillionen entspricht . Sie haben vielleicht schon einmal von dieser Zahl gehört, aber wie wird sie tatsächlich berechnet?$43,252,003,274,489,856,000$

Ein 3x3x3 Rubik's Cube hat sechs Seiten mit jeweils neun Aufklebern. Betrachtet man jedoch die (äußeren) Teile anstelle von Aufklebern, so hat man sechs Mittelteile; acht Eckstücke; und zwölf Randstücke. Da die Zentren nicht verschoben werden können, können wir diese in den Berechnungen ignorieren. Wie für die Ecken und Kanten:

• Es gibt( ) Möglichkeiten zum Anordnen der acht Ecken. Jede Ecke hat drei mögliche Ausrichtungen, obwohl nur sieben (von den acht) unabhängig voneinander ausgerichtet werden können. Die Ausrichtung der achten / letzten Ecke hängt von den vorhergehenden sieben ab, wenn ( ) Möglichkeiten gegeben sind.$8!$$40,320$$3^7$$2,187$
• Es gibt ( ) Möglichkeiten, die zwölf Kanten anzuordnen. Die Hälfte vonDas liegt daran, dass Kanten immer in einer gleichmäßigen Permutation sein müssen, genau dann, wenn die Ecken sind. Elf Kanten können unabhängig voneinander gespiegelt werden, wobei das Spiegeln der zwölften / letzten Kante von den vorhergehenden elf abhängt, wenn ( ) Möglichkeiten gegeben sind.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Zusammen haben wir die folgende Formel:

$$8!×3^7×\frac{12!}{2}×2^{11} = 43,252,003,274,489,856,000$$

^{Quelle: Wikipedia - Rubiks Würfel-Permutationen}

Obwohl dies bereits recht komplex aussieht, ist es für einen 3x3x3-Würfel immer noch recht unkompliziert. Für gerade Würfel ist die Formel etwas anders; Dies ist die Formel für einen 4x4x4-Würfel, zum Beispiel:

$$\frac{8!×3^7×24!^2}{24^7} = 7,401,196,841,564,901,869,874,093,974,498,574,336,000,000,000$$

Welches ist etwa 7,40 Quattuordecillion auf der kurzen Skala .

Und für größere NxNxN-Würfel (dh den aktuellen Weltrekord 33x33x33) wird die Formel erheblich erweitert. Um diese Einführung nicht zu lang zu machen, habe ich stattdessen diese Links hier eingefügt, wo die Permutationen des 4x4x4-Würfels und einiger NxNxN-Würfel anderer Größe mit der folgenden Formel erklärt werden:

• 2x2x2
• 4x4x4
• 5x5x5
• 6x6x6
• 7x7x7
• 33x33x33

Sie wundern sich jetzt vielleicht: Gibt es eine allgemeine Formel, die auf für einen beliebigen x x Würfel basiert ? Das gibt es sicherlich. Hier sind drei völlig unterschiedliche Algorithmen, die alle auf der Basis von exakt dieselben Ergebnisse liefern :$N$$N$$N$$N$$N$

1: Chris Hardwicks Formel:

$$\frac{(24×2^{10}×12!)^{N\pmod2}×(7!×3^6)×(24!)^{\lfloor{\frac{1}{4}×(N^2-2×N)}\rfloor}}{(4!)^{6×\lfloor{\frac{1}{4}×(N-2)^2}\rfloor}}$$

Probieren Sie es auf WolframAlpha.

2: Christopher Mowlas Trigger Formel:

$$8!×3^7×\left(\frac{24!}{(4!)^6}\right)^{\frac{1}{4}×((N-1)×(N-3)+\cos^2(\frac{N×\pi}{2}))}×(24!)^{\frac{1}{2}×(N-2-\sin^2(\frac{N×\pi}{2}))}×(12!×2^{10})^{\sin^2(\frac{N×\pi}{2})}×\frac{1}{24^{\cos^2(\frac{N×\pi}{2})}}$$

Probieren Sie es auf WolframAlpha.

3: Christopher Mowlas Primzahlen Formel:

$$2^{\frac{1}{2}×(2×N×(N+7)-17-11×(-1)^N)}×3^{N×(N+1)+2}×5^{\frac{1}{2}×(2×N×(N-2)+1+(-1)^N)}×7^{\frac{1}{8}×(6×N×(N-2)+3+5×(-1)^N)}×11^{\frac{1}{4}×(2×N×(N-2)-1+(-1)^N)}×96577^{\frac{1}{8}×(2×N×(N-2)-3+3×(-1)^N)}$$

wo ist .$96577$$(13×17×19×23)$

Probieren Sie es auf WolframAlpha.

^{Quelle: Cubers-reddit - Mathematische Zählformeln für die Anzahl der Positionen, die Anzahl Gottes usw.}

Herausforderung:

Wählen und implementieren Sie eine dieser drei Formeln (oder Ihre eigene Ableitung), die bei einer Eingabe-Ganzzahl im Bereich das richtige Ergebnis liefert.$N$$[2,100]$

Herausforderungsregeln:

• Es steht Ihnen frei, eine andere Formel als diese drei zu verwenden. Beachten Sie jedoch, dass diese drei nachweislich korrekt sind. Wenn Sie eine andere Formel verwenden, fügen Sie bitte einen Link hinzu, über den Sie die Formel erhalten haben (oder wenn Sie selbst darauf gekommen sind, fügen Sie eine ausführliche Erläuterung hinzu). Und ich werde nach allen ganzen Zahlen im Bereich suchen, ob die Ausgabe korrekt ist. Vielleicht könnte Inspiration in der Oeis für diese Sequenz gefunden werden: A075152 .
• Wenn Ihre Sprache automatisch eine wissenschaftliche Ausgabe ausgibt (dh anstelle der Zahl nach der 4x4x4-Formel), ist dies zulässig. Fügen Sie Ihrer Antwort jedoch zusätzlichen Code hinzu, um diese wissenschaftliche Rundung in eine exakte Ausgabe umzuwandeln, damit die Ergebnisse überprüft werden können, da Rundungsfehler aufgrund der Gleitkommapräzision während der Ausführung der Formel in Ihrem Code nicht zulässig sind - das tatsächliche Ergebnis sollte es sein genau.$1.401...×10^{45}$
• Ihr Programm / Ihre Funktion sollte für mindestens die Eingaben im Bereich korrekt sein (obwohl, da bereits eine Riesen-Arsch-Zahl ergibt, wird jedes größere wahrscheinlich auch funktionieren, wenn Sie dies ausgeben können eine richtig).$[2,100]$$N=100$$N$
• Sie dürfen nicht alle möglichen Permutationen mit einem Zähler durchlaufen, da dies in einem angemessenen Zeitraum zu keiner Ausgabe führen würde. Nur die Implementierung einer Formel (entweder eine der drei bereitgestellten, eine Ableitung einer dieser Formeln oder eine völlig neue Formel) oder eine andere Methode, die in angemessener Zeit die richtigen Ergebnisse liefert (natürlich ohne harte Kodierung) ) ist erlaubt. Ich habe darüber nachgedacht, eine eingeschränkte Zeit hinzuzufügen , um dies durchzusetzen, aber ich persönlich bin gegen eine zeitliche Beschränkung in Kombination mit Code-Golf , also werde ich das nicht tun. Vergewissern Sie sich dennoch, dass Ihr Programm die Antworten gibt. Wenn es aus irgendeinem Grund für TIO zu langsam ist, fügen Sie zur Überprüfung einige Screenshots mit der Ausgabe von Ihrem lokalen Computer hinzu.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Hier die Testfälle für im Bereich (für größere Testfälle können Sie die obigen WolframAlpha-Links verwenden):$N$$[2,10]$

n=2
3674160

n=3
43252003274489856000

n=4
7401196841564901869874093974498574336000000000

n=5
282870942277741856536180333107150328293127731985672134721536000000000000000

n=6
157152858401024063281013959519483771508510790313968742344694684829502629887168573442107637760000000000000000000000000

n=7
19500551183731307835329126754019748794904992692043434567152132912323232706135469180065278712755853360682328551719137311299993600000000000000000000000000000000000

n=8
35173780923109452777509592367006557398539936328978098352427605879843998663990903628634874024098344287402504043608416113016679717941937308041012307368528117622006727311360000000000000000000000000000000000000000000000000

n=9
14170392390542612915246393916889970752732946384514830589276833655387444667609821068034079045039617216635075219765012566330942990302517903971787699783519265329288048603083134861573075573092224082416866010882486829056000000000000000000000000000000000000000000000000000000000000000

n=10
82983598512782362708769381780036344745129162094677382883567691311764021348095163778336143207042993152056079271030423741110902768732457008486832096777758106509177169197894747758859723340177608764906985646389382047319811227549112086753524742719830990076805422479380054016000000000000000000000000000000000000000000000000000000000000000000000000000000000

ANMERKUNG: Da dies eine Code-Golf- Herausforderung ist, läuft es im Wesentlichen darauf hinaus, eine dieser drei Formeln (oder eine Ableitung / Ihre eigene Methode, die immer noch die richtigen Ergebnisse liefert) so kurz wie möglich zu implementieren.

Wolfram Language (Mathematica) , 59 Bytes

f@n_:=(s=24^6)(24!/s)^(m=n-2)f@m
f@2=7!3^6
f@3=4!12!2^10f@2

Probieren Sie es online!

verwendet Herbert Kociembas Algorithmus, der auf der OEIS-Seite zu finden ist

Hier ist die rekursive Formel:
a(1)=1; a(2)=7!*3^6; a(3)=8!*3^7*12!*2^10; a(n)=a(n-2)*24^6*(24!/24^6)^(n-2)

6 Bytes von @Peter Taylor gespeichert

Ein weiteres Byte, das von @Expired Data gespeichert wurde

x86-Maschinencode, 119 Byte

Hexdump:

60 c6 02 02 33 db be 25 01 10 00 f6 c1 01 74 05
be 26 2a b2 36 33 ed 51 b1 06 33 ff 53 8a 04 1a
f6 e1 03 c7 b5 0a f6 f5 88 64 1a 02 66 98 8b f8
4b 79 ea 5b 43 43 f6 f5 66 89 02 84 c0 75 0c 60
8b fa 8d 72 01 8b cb f3 a4 61 4b 41 d1 ee 72 ca
75 f9 be 1d d4 0d 10 4d 79 be 59 49 49 8b e9 be
06 02 02 22 83 f9 02 73 ae c6 44 1a 01 00 80 0c
1a 30 4b 79 f9 61 c3

Die Funktion nimmt die Anzahl nin ecx, und einen Zeiger auf eine Zeichenkette auf Aufhellblitz edx(dh fastcallconvention).

Bevor ich den Quellcode zeige, einige Erklärungen, wie es die Sache macht. Es wird die rekursive Formel verwendet, die ich folgendermaßen geschrieben habe:

init = 2
m1 = 24^6 = 6*8*9*16*24*32*36
m2 = 24!/24^6 = 6*7*9*10*11*17*19*21*22*23*25*26*35
num(2) = init * 6*7*9*12*15*27
num(3) = init * 6*8*9*12*16*18*20*24*27*28*30*32*33*35*36
num(n+2) = num(n) * m1 * m2^n

Alles, was der Code tun sollte, ist die Multiplikation mit kleinen Zahlen. Die Zahlen liegen im Bereich von 6 bis 36, was klein genug ist, um in einer 32-Bit-Bitmap dargestellt zu werden. Ich speichere eigentlich nicht das Bit, das die Multiplikation mit 6 darstellt - so kann ich den Code in einer do-whileSchleife anordnen , beginnend mit der bedingungslosen Multiplikation mit 6.

Die großen Zahlen werden in Dezimalform dargestellt - jedes Byte ist ein Wert im Bereich von 0 bis 9, beginnend mit dem MSB.

Die Multiplikation wird von LSB zu MSB durchgeführt; Es wird davon ausgegangen, dass die Anzahl der Stellen bei jeder Multiplikation um 2 zunimmt. Nach der Multiplikation mit einem kleinen Faktor wie 6 wächst die Anzahl der Stellen möglicherweise nur um 1. Wenn also MSB = 0 ist, wird das gesamte Zwischenergebnis nach links verschoben. Es kann tatsächlich vorkommen, dass die Anzahl der Stellen überhaupt nicht wächst und das MSB dann immer noch 0 ist. Dieses Problem wird jedoch behoben, wenn der Code mit größeren Faktoren fortfährt.

Da der Multiplikationscode groß ist, möchte ich ihn nicht zweimal ausdrücken. Ich möchte es auch nicht in eine Funktion verschieben, da der Maschinencode zum Aufrufen einer Funktion groß ist. Also habe ich die äußeren Schleifen so umgestellt, dass der Multiplikationscode nur einmal benötigt wird.

C-Code:

void num(int n, char* x)
{
    *x = 2;
    int len = 1;
    int exp_i;
    uint32_t m32_1;
    int m1;
    int carry;
    int temp;
    int str_i;
    bool cf;

    if (n % 2 == 0)
    {
        m32_1 = 0x100125; // 6*7*9*12*15*27
    }
    else
    {
        m32_1 = 0x36b22a26; // 6*8*9*12*16*18*20*24*27*28*30*32*33*35*36
    }

    exp_i = 0;
    while (true)
    {
        for (; exp_i >= 0; --exp_i)
        {
            m1 = 6;
            cf = true;
        do_mult:
            carry = 0;
            for (str_i = len - 1; str_i >= 0; --str_i)
            {
                temp = x[str_i] * m1 + carry;
                x[str_i + 2] = temp % 10;
                carry = temp / 10;
            }
            len += 2;
            x[1] = carry % 10;
            carry /= 10;
            x[0] = carry;
            if (carry == 0)
            {
                --len;
                for (str_i = 0; str_i < len; ++str_i)
                    x[str_i] = x[str_i + 1];
            }

        shift_m1:
            ++m1;
            cf = m32_1 & 1;
            m32_1 >>= 1;
            if (cf)
                goto do_mult;
            if (m32_1)
                goto shift_m1;

            m32_1 = 0x100dd41d; // 24!/24^6 = 6*7*9*10*11*17*19*21*22*23*25*26*35
        }
        --n;
        --n;
        exp_i = n;
        if (n < 2)
            break;
        m32_1 = 0x22020206; // 24^6

    }
    x[len] = 0;
    for (str_i = len - 1; str_i >= 0; --str_i)
    {
        x[str_i] += '0';
    }
}

Demontage:

60                     pushad;
C6 02 02               mov byte ptr [edx], 2; // edx = x
33 DB                  xor ebx, ebx; // ebx = len - 1
BE 25 01 10 00         mov esi, 0x100125; // esi = m32_1
F6 C1 01               test cl, 1;
74 05                  jz skip1;
BE 26 2A B2 36         mov esi, 0x36b22a26; // esi = m32_1
                   skip1:
33 ED                  xor ebp, ebp; // ebp = exp_i

                   loop_n:

51                     push ecx;
                   loop_exp_i:
B1 06                  mov cl, 6; // cl = m1
                   do_mult:
33 FF                  xor edi, edi; // edi = carry
53                     push ebx; // ebx = str_i
                   loop_str_i:
8A 04 1A               mov al, [edx + ebx];
F6 E1                  mul cl;
03 C7                  add eax, edi;
B5 0A                  mov ch, 10;
F6 F5                  div ch;
88 64 1A 02            mov [edx + ebx + 2], ah;
66 98                  cbw;
8B F8                  mov edi, eax;
4B                     dec ebx;
79 EA                  jns loop_str_i;

5B                     pop ebx; // ebx = len - 1
43                     inc ebx;
43                     inc ebx;
F6 F5                  div ch;
66 89 02               mov [edx], ax;

84 C0                  test al, al;
75 0C                  jnz skip2;

60                     pushad;
8B FA                  mov edi, edx;
8D 72 01               lea esi, [edx + 1];
8B CB                  mov ecx, ebx;
F3 A4                  rep movsb;
61                     popad;
4B                     dec ebx;
                   skip2:

                   shift_m1:
41                     inc ecx;
D1 EE                  shr esi, 1;
72 CA                  jc do_mult;
75 F9                  jnz shift_m1;

BE 1D D4 0D 10         mov esi, 0x100dd41d;

4D                     dec ebp;
79 BE                  jns loop_exp_i;

59                     pop ecx; // ecx = n
49                     dec ecx;
49                     dec ecx;
8B E9                  mov ebp, ecx;
BE 06 02 02 22         mov esi, 0x22020206;
83 F9 02               cmp ecx, 2;
73 AE                  jae loop_n;

C6 44 1A 01 00         mov byte ptr [edx + ebx + 1], 0;
                   loop_to_ascii:
80 0C 1A 30            or byte ptr [edx + ebx], '0';
4B                     dec ebx;
                       dec         ebx  
79 F9                  jns loop_to_ascii;

61                     popad;
C3                     ret;

Die Laufzeit für n = 100 beträgt ungefähr 4 Sekunden und das Ergebnis ist eine Zahl mit 38416 Ziffern:

23491019577617 (viele Ziffern hier) ... (viele Nullen hier) 0000000000000000

05AB1E , 38 Bytes

Erster Versuch.
Verwendet Chris Hardwicks Formel .
Werde versuchen weiter zu golfen und erklären wann ich Zeit habe.

24©To12!PIÉm7!729®!InI·-4÷mP®IÍn4÷6*m÷

Probieren Sie es online!

Julia 1.0 , 83 76 Bytes

n->^(24576*~12,n%2)*3^6*~7(~24)^((m=n-2)n÷4)/24^(m^2÷4*6)
~n=prod(big,1:n)

Probieren Sie es online!

Verwendet Chris Hardwicks Formel. Übernimmt die Eingabe als Big Integer.

Vielen Dank an H.PWiz für -7 Bytes

Python 2 , 72 Bytes

lambda n:3674160*61600**(n%2)*24**(~-n/2*6)*0xb88d4641131f0**(n*(n-2)/4)

Probieren Sie es online!

4 Bytes durch Kopieren n*(n-2)/4von Neil gespeichert .

Wolfram Language (Mathematica) , 67 Byte

Mit Chris Hardwicks Formel.

(12!24576)^Mod[#,2]7!729(24!)^⌊#(#-2)/4⌋/24^(6⌊(#-2)^2/4⌋)&

Probieren Sie es online!

JavaScript (Node.js) , 81 Bytes

Herbert Kociembas rekursive Formel. Nimmt ein BigInt als Eingabe.

f=n=>[1n,3674160n,322252536375n<<27n][--n]||f(--n)*0xb640000n*0xb88d4641131f0n**n

Probieren Sie es online!

---

JavaScript (Node.js) ,  102 98  96 Byte

Chris Hardwicks Formel. Nimmt ein BigInt als Eingabe.

n=>(n&1n?1403325n<<25n:4n)*918540n*0x83629343d3dcd1c00000n**(n*n-n-n>>2n)/24n**(6n*(n*n/4n-~-n))

Probieren Sie es online!

JavaScript (Node.js) , 77 75 73 Byte

n=>0xb88d4641131f0n**(n*(n-2n)/4n)*13824n**n*851558400n**(n%2n)*315n>>14n

Probieren Sie es online! Basierend auf Christopher Mowlas Formel. Nimmt ein BigInt als Eingabe. Testgeschirr schamlos von @Arnauld gestohlen. 0xb88d4641131f0nist 3246670537110000nin Dezimalzahl. Erläuterung: Ich habe mit dem letzten Prim-Exponenten begonnen und ihn auf vereinfacht n*(n-2n)/4n(dies ist eine Ganzzahldivision, daher brauche ich keine Anpassung für ungerade Zahlen). Ich untersuchte dann die anderen Primzahlen, um festzustellen, ob ihre Exponenten mit diesem Wert in Beziehung standen (den ich als bezeichnen werde o), und stellte fest, dass sie auf eine Art und Weise waren, wenn ich die Verwendung der Parität von n(den ich als bezeichnen werde) erlaubte p). Die Formeln für die Exponenten lauten wie folgt:

23:       o
19:       o
17:       o
13:       o
11:      2o +   p
 7:      3o +   p +  1
 5:      4o +  2p +  1
 3: 3n + 4o +  3p +  2
 2: 9n + 4o + 14p - 14

Die Potenzen können dann nach Exponenten gruppiert werden, beispielsweise pist dies der Exponent von 11*7*5**2*3**3*2**14.

Schläger , 151 141 Bytes

-7 bytes dank fede s.!

(λ(n[e expt])(/(*(e 11771943321600(modulo n 2))3674160(e 620448401733239439360000(floor(/(*(- n 2)n)4))))(e 24(*(floor(/(sqr(- n 2))4))6))))

Probieren Sie es online!

Die längste Antwort mit Chris Hardwicks Formel :)

Python 2 , 122 Bytes

import math
f=math.factorial
x=lambda n:(1,f(7)*729,f(8)*3**7*f(12)*1024)[n-1]if n<4else x(n-2)*24**6*(f(24)/24**6)**(n-2)

Probieren Sie es online!

Verwendet die rekursive Methode von Herbert Kociemba.

-2 Bytes dank Herman L

Jelly ,  39  38 Bytes

^{Ich habe das Gefühl, ein paar Golfplätze verpasst zu haben, aber ...}

12!×⁽^K*Ḃɓ_2×ṭ¥⁸:4×1,6“ð¥‘!¤*:/ד9Ḟɠ’×

Ein monadischer Link, der Chris Hardwicks Formel implementiert.

Probieren Sie es online! Oder schauen Sie in die Testsuite (n=[1..33]).

CJam (47 Bytes)

qi[1_7m!Z6#*_3*Cm!*2D#*]{2-_j24_m!\6#:P/@#*P*}j

Online-Demo

$$a(n) = \begin{cases} 1 & \textrm{ if } n \in \{0,1\} \\ 7! \times 3^6 & \textrm{ if } n=2 \\ a(n-1) \times 3\times 12!\times 2^{13} & \textrm{ if } n=3 \\ a(n-2) \times \left(\frac{24!}{24^6}\right)^{n-2} \times 24^6 & \textrm{ if } n>3 \end{cases}$$ j

Jelly , 43 Bytes

_2²:4×6*@24
²_Ḥ:4;ḂU
“€ð‘!×⁽^K,1*ÇPד9Ḟɠ’:Ñ

Probieren Sie es online!

Symbol , 125 bis 110 Bytes

procedure f(n)
q:=1;every q*:=1 to 24
return 11771943321600^(n%2)*5040*3^6*q^(n*(t:=n-2)/4)/24^(6*(t^2/4))
end

Probieren Sie es online!

C (gcc) -lgmp, 279 Bytes

#include "gmp.h"
#define s mpz_init_set_str
#define m(X)mpz_##X
f(int N,m(t)_){m(t)x;m(init)(x);m(init_set_str)(_,N&1?"3LFbOUwC":"1",62);m(mul_si)(_,_,3674160);m(fac_ui)(x,24);m(pow_ui)(x,x,(N*N-2*N)/4);m(mul)(_,_,x);m(set_si)(x,24);N-=2;m(pow_ui)(x,x,6*N*N/4);m(tdiv_q)(_,_,x);}

Probieren Sie es online!

Perl 6 , 85 Bytes

{0xAB4DE800000**($_%2)*3674160*([*] 1..24)**($_*($_-2)div 4)/24**(($_-2)**2 div 4*6)}

Probieren Sie es online!

Haskell , 86 85 74 Bytes

^{-1 Byte gespeichert dank H.PWiz
-11 Byte gespeichert dank Max Yekhlakov}

a=24^6
r 2=3674160
r 3=r 2*a*61600
r n=r(n-2)*a*div(product[2..24])a^(n-2)

Probieren Sie es online!

Python 2 , 92 Bytes

lambda n:0xab4de800000**(n%2)*3674160*0x83629343d3dcd1c00000**(n*(n-2)/4)/24**((n-2)**2/4*6)

Probieren Sie es online!

Schale , 51 48 44 Bytes

-4 Bytes dank H.PWiz

÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12

Probieren Sie es online!

Dies ist die Formel von Chris Hardwick. Dies ist auch mein erstes Schalenprogramm, daher wären alle Tipps sehr willkommen.

C ++, 187 185 180 176 195 (es gab einen Fehler) 193 175 Bytes (mit Hilfe von Ceiling Cat)

Hierfür werden der GMP C ++ - Wrapper (GNU Multi-Precision Library) und die von @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ) verwendete Formel verwendet .

Verwenden Sie g++ -g rubix.cpp -lgmp -lgmpxxzum Kompilieren und Link

#include <gmpxx.h>
#define R return
using z=mpz_class;z p(z a,z b){z c=1;while(b--)c*=a;R c;}z r(z n){if(n==2)R 3674160;if(n==3)R z("pX4dIaR7jDk",62);R r(n-2)*p(24,6)*p(z("ErvSErbeq",62),n-2);}

ungolfed, mit testcode

#include <gmpxx.h>
#include <iostream>
mpz_class p(mpz_class a, mpz_class b) // returns a to power of b. Only works for b  = positive integer
{
    mpz_class c=1;

    while(b--)
        c*=a;

    return c;
}


mpz_class r(mpz_class n) // returns the rubix permutations for a cube of size n
{
    if(n==2)
        return 3674160; // 7!*3^6;

    if(n==3)
        return z("pX4dIaR7jDk",62); // 43252003274489856000 = 8!*3^7*12!*2^10

    return r(n-2) * p(24,6) * p(z("ErvSErbeq", 62), n-2);

    // "ErvSErbeq"base 62 = 3246670537110000 = (24!/24^6)        
}    

main()
{
    for(int i=2; i<34; i++)
        std::cout<<i<<'\t'<<r(i) << std::endl;
}

https://tio.run/##PZAxb4MwEIV3foWVDrETqBpARMImWZqha7t0iFQZ4xC3xrg2tJERf73UIVXfcE937zvpdEzrqGZsmu6EYrKvOKkbfbncn3dBb4WqgSsa7d6YpNZiBzR0gIYOlGhwgBUb/H0WksMyihBbFRQb3vVGAYZHB4xnFRr@Rqoo4n2SbdNN9pD7Jtk7uNCvafVEn7fvjx@LMItRbqCKYrTSME7D7OoeOpivl4Mp@eeMhFcAj//3AiJa2xlOm13QUKEgCoYAeJ1aA4XqgChiDARJUl/XazRnXrar8py1fUeIIGR57JaE@AUECLllXFUSB2Mw/bCTpLWdIjm/5ua/

TI-BASIC, 63 62 Bytes (nicht konkurrierend)

{fPart(.5Ans),1,1,-6}int(4⁻¹{8,4,Ans²-2Ans,(Ans-2)²:prod({9*11!2^15,7!3^6,24!,24}^Ans

Ausdruck, der die Eingabe als Ganzzahl annimmt Ans. Implementierung der Chris Hardwick Formel. Nicht konkurrierend, da die Hardware, auf der es ausgeführt wird, nur bis zu 16 Dezimalstellen speichert, sodass die Antwort niemals 100% genau ist.

Erläuterung:

{fPart(.5Ans),1,1,-6}              # the list {(N (mod 2))/2,1,1,-6}
                                   # implicitly multiplied by
int(4⁻¹{8,4,Ans²-2Ans,(Ans-2)²     # the list {2,1,⌊¼(N²-2N)⌋,⌊¼(N-2)²⌋}
:                                  # store this list of the formula's exponents as Ans
     {9*11!2^15,7!3^6,24!,24}      # list of the formula's bases
                             ^Ans  # raised to their exponents
prod(                              # multiplied together
                                   # implicit print