Wprowadzenie:

Kostka Rubika 3x3x3 ma możliwych , co stanowi około 43 kwintillionów . Być może słyszałeś już o tej liczbie, ale jak to się faktycznie liczy?$43,252,003,274,489,856,000$

Kostka Rubika 3x3x3 ma sześć stron, każda z dziewięcioma naklejkami. Jednak patrząc na (zewnętrzne) elementy zamiast naklejek, mamy sześć elementów środkowych; osiem narożników; i dwanaście kawałków krawędzi. Ponieważ centrów nie można przenieść, możemy zignorować je w obliczeniach. Jeśli chodzi o rogi i krawędzie:

• Jest(40 ) sposobów na ustawienie ośmiu rogów. Każdy narożnik ma trzy możliwe orientacje, chociaż tylko siedem (z ośmiu) można ustawić niezależnie; orientacja ósmego / końcowego rogu zależy od poprzednich siedmiu, biorąc pod uwagę ( ) możliwości.$8!$$40,320$$3^7$$2,187$
• Istnieją ( ) sposobów na ułożenie dwunastu krawędzi. Połówka zponieważ krawędzie muszą zawsze znajdować się w równej permutacji dokładnie wtedy, gdy są narożniki. Jedenaście krawędzi można odwracać niezależnie, z odwróceniem krawędzi dwunastej / końcowej w zależności od poprzedzającej jedenastki, biorąc pod uwagę ( ) możliwości.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Podsumowując, mamy następującą formułę:

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

^{Źródło: Wikipedia - Permutacje kostki Rubika}

Chociaż może to już wyglądać dość skomplikowane, wciąż jest dość proste jak na kostkę 3x3x3. W przypadku nawet kostek formuła jest nieco inna; oto wzór na kostkę 4x4x4 na przykład:

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

To jest około 7,40 quattuordecillion w krótkiej skali .

A w przypadku większych kostek NxNxN (tj. Aktualny rekord świata 33x33x33) formuła zostanie nieco rozszerzona. Aby jednak nie wprowadzać tego wprowadzenia zbyt długo, umieściłem tutaj te linki, gdzie wyjaśniono permutacje kostki 4x4x4 i innych kostek NxNxN o innych rozmiarach z uzyskaną formułą:

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

Być może już się zastanawiasz: czy istnieje ogólna formuła oparta na dla dowolnej kostki x x ? Z pewnością jest. Oto trzy zupełnie różne algorytmy, z których wszystkie dają dokładnie takie same wyniki w oparciu o :$N$$N$$N$$N$$N$

1: Formuła Chrisa Hardwicka:

$$\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}}$$

Wypróbuj na WolframAlpha.

2: Formuła trig Christophera Mowli:

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

Wypróbuj na WolframAlpha.

3: Liczby pierwsze Christophera Mowli Wzór:

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

gdzie to .$96577$$(13×17×19×23)$

Wypróbuj na WolframAlpha.

^{Źródło: Cubers-reddit - Matematyczne formuły liczenia liczby pozycji, liczby Boga itp.}

Wyzwanie:

Wybierz i zaimplementuj jedną z tych trzech formuł (lub własną pochodną), która podając liczbę całkowitą wejściową w zakresie , daje prawidłowy wynik.$N$$[2,100]$

Zasady konkursu:

• Możesz użyć innej formuły oprócz tych trzech, ale pamiętaj, że te trzy okazały się poprawne. Jeśli używasz innej formuły, dodaj link, skąd ją masz (lub jeśli sam ją wymyślisz, dodaj dogłębne wyjaśnienie). I sprawdzę, czy wszystkie liczby całkowite w zakresie są prawidłowe. Być może inspirację można znaleźć w Oeis dla tej sekwencji: A075152 .
• Jeśli twój język automatycznie generuje wyniki naukowe (tj. zamiast liczby po formule 4x4x4), jest to dozwolone. Ale proszę dodać dodatkowy kod do swojej odpowiedzi, aby przekonwertować to zaokrąglenie naukowe na dokładny wynik, aby można było zweryfikować wyniki, ponieważ błędy zaokrąglania wynikające z precyzji zmiennoprzecinkowej podczas wykonywania formuły w kodzie są niedozwolone - rzeczywisty wynik powinien być dokładny.$1.401...×10^{45}$
• Twój program / funkcja powinna być poprawna co najmniej dla danych wejściowych z zakresu (chociaż, ponieważ już daje ogromną liczbę, każdy większy prawdopodobnie będzie również działał, jeśli będziesz w stanie to wyprowadzić jeden poprawnie).$[2,100]$$N=100$$N$
• Nie można zapętlać wszystkich możliwych kombinacji z licznikiem, ponieważ nigdy nie dałoby to niczego w rozsądnym czasie. Tylko wdrożenie formuły (jednej z trzech podanych, pochodnej jednej z nich lub zupełnie nowej formuły) lub innej metody, która da prawidłowe wyniki w rozsądnym czasie (oczywiście bez twardego kodowania) ) jest dozwolone. Myślałem o dodaniu ograniczonego czasu, aby to wymusić, ale osobiście jestem przeciwny ograniczonemu czasowi w połączeniu z golfem , więc nie zrobię tego. Mimo to upewnij się, że Twój program udziela odpowiedzi, a jeśli z jakiegoś powodu jest zbyt wolny dla TIO, dodaj kilka zrzutów ekranu z danymi wyjściowymi z komputera lokalnego w celu weryfikacji.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
• Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

Oto przypadki testowe dla w zakresie (możesz użyć powyższych linków WolframAlpha dla większych przypadków testowych):$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

UWAGA: Ponieważ jest to wyzwanie dla golfa , sprowadza się ono do: wdrożenia jednej z tych trzech formuł (lub pochodnej / własnej metody, która nadal daje prawidłowe wyniki) tak krótko, jak to możliwe.

Wolfram Language (Mathematica) , 59 bajtów

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

Wypróbuj online!

wykorzystuje algorytm Herberta Kociemby znaleziony na stronie OEIS

oto rekurencyjna formuła:
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 bajtów zapisanych przez @Peter Taylor

jeszcze jeden bajt zapisany przez @Expired Data

kod maszynowy x86, 119 bajtów

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

Funkcja otrzymuje numer nw ecxoraz wskaźnik do łańcucha znaków do wypełnienia edx(czyli fastcallkonwencja).

Zanim pokażę kod źródłowy, kilka wyjaśnień, jak to działa. Wykorzystuje formułę rekurencyjną, którą napisałem w następujący sposób:

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

Więc wszystko, co powinien zrobić kod, to pomnożenie przez małe liczby. Liczby mieszczą się w zakresie 6 ... 36, który jest wystarczająco mały, aby można go było przedstawić w 32-bitowej mapie bitowej. Właściwie nie przechowuję bitu reprezentującego mnożenie przez 6 - pozwala mi to ułożyć kod w do-whilepętli, zaczynając od bezwarunkowego pomnożenia przez 6.

Duże liczby są reprezentowane przy użyciu postaci dziesiętnej - każdy bajt jest wartością z zakresu 0 ... 9, zaczynając od MSB.

Mnożenie odbywa się z LSB do MSB; zakłada, że ​​liczba cyfr wzrośnie o 2 dla każdego pomnożenia. Po pomnożeniu przez mały współczynnik, taki jak 6, liczba cyfr może wzrosnąć tylko o 1. Więc jeśli MSB = 0, przesuwa cały wynik pośredni w lewo. Może się zdarzyć, że liczba cyfr w ogóle się nie zwiększy, a wtedy MSB będzie nadal wynosić 0, ale ten problem sam się rozwiąże, gdy kod przejdzie na większe czynniki.

Ponieważ kod mnożenia jest duży, nie chcę go umieszczać dwa razy. Nie chcę też przenosić go do funkcji, ponieważ kod maszynowy do wywoływania funkcji jest duży. Przestawiłem więc zewnętrzne pętle w taki sposób, że kod mnożenia jest potrzebny tylko raz.

Kod C:

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';
    }
}

Demontaż:

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;

Czas działania dla n = 100 wynosi około 4 sekund, a wynikiem jest liczba z 38416 cyframi:

23491019577617 (wiele cyfr tutaj) ... (wiele zer tutaj) 0000000000000000

05AB1E , 38 bajtów

Pierwsza próba.
Wykorzystuje formułę Chrisa Hardwicka .
Spróbuję dalej grać w golfa i wyjaśnię, kiedy będę miał czas.

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

Wypróbuj online!

Julia 1.0 , 83 76 bajtów

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

Wypróbuj online!

Wykorzystuje formułę Chrisa Hardwicka. Pobiera dane wejściowe jako Big integer.

Dzięki H.PWiz za -7 bajtów

Python 2 , 72 bajty

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

Wypróbuj online!

Zapisano 4 bajty, kopiując n*(n-2)/4z Neila .

Wolfram Language (Mathematica) , 67 bajtów

Korzystanie z formuły Chrisa Hardwicka.

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

Wypróbuj online!

JavaScript (Node.js) , 81 bajtów

Recursywna formuła Herberta Kociemby. Pobiera BigInt jako wejście.

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

Wypróbuj online!

---

JavaScript (Node.js) ,  102 98  96 bajtów

Wzór Chrisa Hardwicka. Pobiera BigInt jako wejście.

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

Wypróbuj online!

JavaScript (Node.js) , 77 75 73 bajtów

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

Wypróbuj online! Na podstawie formuły Christophera Mowli. Pobiera BigInt jako wejście. Uprząż testowa bezwstydnie skradziona z @Arnauld. 0xb88d4641131f0njest 3246670537110000nw systemie dziesiętnym. Objaśnienie: Zacząłem od ostatniego wykładnika głównego i uprościłem go n*(n-2n)/4n(jest to podział na liczby całkowite, więc nie potrzebuję korekty liczb nieparzystych). Następnie zbadałem pozostałe liczby pierwsze, aby sprawdzić, czy ich wykładniki są powiązane z tą wartością (którą będę określał jako o), i stwierdziłem, że były one modne, jeśli pozwolę na użycie parzystości n(którą będę określał jako p). Formuły wykładników są następujące:

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

Moce mogą być następnie pogrupowane według wykładnika, więc na przykład pjest wykładnikiem wykładnika 11*7*5**2*3**3*2**14.

Rakieta , 151 141 bajtów

-7 bajtów dzięki 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))))

Wypróbuj online!

Najdłuższa odpowiedź przy użyciu Formuły Chrisa Hardwicka :)

Python 2 , 122 bajty

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)

Wypróbuj online!

Wykorzystuje metodę rekurencyjną Herberta Kociemby.

-2 bajty dzięki Hermanowi L.

Galaretka ,  39  38 bajtów

^{Czuję, że przegapiłem kilka golfów, ale ...}

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

Monadyczny link implementujący Formułę Chrisa Hardwicka.

Wypróbuj online! Lub zobacz test-suite (n=[1..33]).

CJam (47 bajtów)

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

Demo online

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

Galaretka , 43 bajty

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

Wypróbuj online!

Ikona , 125 110 bajtów

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

Wypróbuj online!

C (gcc) -lgmp, 279 bajtów

#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);}

Wypróbuj online!

Perl 6 , 85 bajtów

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

Wypróbuj online!

Haskell , 86 85 74 bajtów

^{-1 bajt zapisany dzięki H.PWiz
-11 bajtów zapisany dzięki 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)

Wypróbuj online!

Python 2 , 92 bajty

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

Wypróbuj online!

Łuska , 51 48 44 bajtów

-4 bajty dzięki H.PWiz

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

Wypróbuj online!

To Formuła Chrisa Hardwicka. To także mój pierwszy program łuskowy, więc wszelkie wskazówki byłyby mile widziane.

C ++, 187 185 180 176 195 (wystąpił błąd) 193 175 bajtów (z pomocą kota na suficie)

Wykorzystuje to opakowanie GMP C ++ (biblioteka wieloprecyzyjna GNU) oraz formułę używaną przez @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Służy g++ -g rubix.cpp -lgmp -lgmpxxdo kompilowania i łączenia

#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);}

bez golfa, z kodem testowym

#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 bajtów , (niekonkurencyjny)

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

Wyrażenie, które przyjmuje dane wejściowe jako liczbę całkowitą Ans. Wdrożenie formuły Chrisa Hardwicka. Niekonkurencyjny, ponieważ sprzęt, na którym działa, zapisze tylko 16 miejsc po przecinku, więc odpowiedź nigdy nie będzie w 100% dokładna.

Wyjaśnienie:

{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