Pengantar:

Kubus Rubik 3x3x3 memiliki kemungkinan permutasi, yaitu sekitar 43 triliun . Anda mungkin pernah mendengar tentang nomor ini sebelumnya, tetapi bagaimana cara menghitungnya?$43,252,003,274,489,856,000$

Kubus Rubik 3x3x3 memiliki enam sisi, masing-masing dengan sembilan stiker. Melihat pada potongan (eksternal) alih-alih stiker, kami memiliki enam bagian tengah; potongan delapan sudut; dan dua belas potongan tepi. Karena pusat tidak dapat dipindahkan, kami dapat mengabaikannya dalam perhitungan. Adapun sudut dan tepi:

• Ada( ) cara untuk mengatur delapan sudut. Setiap sudut memiliki tiga kemungkinan orientasi, walaupun hanya tujuh (dari delapan) yang dapat diorientasikan secara independen; orientasi sudut delapan / final tergantung pada tujuh sebelumnya, diberikan ( ) kemungkinan.$8!$$40,320$$3^7$$2,187$
• Ada ( ) cara untuk mengatur dua belas tepi. Dibelah dua dariadalah karena ujung harus selalu dalam permutasi genap persis ketika sudut-sudutnya. Sebelas tepi dapat dibalik secara independen, dengan flip kedua belas / tepi akhir tergantung pada sebelas sebelumnya, diberikan ( ) kemungkinan.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Menyatukan ini, kami memiliki rumus berikut:

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

^{Sumber: Wikipedia - Permutasi Kubus Rubik}

Meskipun ini mungkin sudah terlihat cukup kompleks, itu masih agak lurus ke depan untuk 3x3x3 Cube. Bahkan untuk kubus rumusnya sedikit berbeda; ini adalah rumus untuk Cube 4x4x4 misalnya:

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

Yaitu sekitar 7,40 quattuordecillion pada skala pendek .

Dan untuk NxNxN Cubes yang lebih besar (yaitu Rekor Dunia 33x33x33 saat ini) formula akan diperpanjang sedikit. Untuk tidak membuat pengantar ini terlalu lama, saya meletakkan tautan ini di sini, di mana permutasi dari 4x4x4 Cube dan beberapa NxNxN Cubes berukuran lain dijelaskan dengan rumus yang dihasilkan:

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

Anda mungkin bertanya-tanya sekarang: apakah ada rumus umum berdasarkan untuk setiap x x Cube? Pasti ada. Berikut adalah tiga algoritma yang sangat berbeda, semuanya memberikan hasil yang sama persis berdasarkan :$N$$N$$N$$N$$N$

1: Formula Chris Hardwick:

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

Cobalah di WolframAlpha.

2: Formula trigonometri Christopher Mowla:

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

Cobalah di WolframAlpha.

3: Formula dasar Christopher Mowla:

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

di mana adalah .$96577$$(13×17×19×23)$

Cobalah di WolframAlpha.

^{Sumber: Cubers-reddit - Rumus Penghitungan Matematika dari Jumlah Posisi, Nomor Tuhan, dll.}

Tantangan:

Pilih dan terapkan salah satu dari tiga rumus ini (atau turunan Anda sendiri), yang diberi bilangan bulat input dalam kisaran , menghasilkan hasil yang benar.$N$$[2,100]$

Aturan tantangan:

• Anda bebas menggunakan formula lain di samping ketiganya, tetapi perlu diingat bahwa ketiganya terbukti benar. Jika Anda menggunakan formula lain, silakan tambahkan tautan dari mana Anda mendapatkannya (atau jika Anda datang sendiri, tambahkan penjelasan mendalam). Dan saya akan memeriksa semua bilangan bulat dalam kisaran jika outputnya benar. Mungkin inspirasi dapat ditemukan di oeis untuk urutan ini: A075152 .
• Jika bahasa Anda secara otomatis menampilkan keluaran ilmiah (yaitu alih-alih angka setelah rumus 4x4x4) ini diperbolehkan. Tetapi tolong tambahkan kode tambahan untuk jawaban Anda untuk mengonversi pembulatan ilmiah ini menjadi keluaran yang tepat sehingga hasilnya dapat diverifikasi, karena kesalahan pembulatan karena presisi titik mengambang selama pelaksanaan rumus dalam kode Anda tidak diperbolehkan - hasil yang sebenarnya harus tepat.$1.401...×10^{45}$
• Program / fungsi Anda harus benar untuk setidaknya input dalam kisaran (walaupun, karena sudah menghasilkan angka yang sangat besar, lebih besar mungkin akan bekerja juga jika Anda dapat menampilkan ini satu dengan benar).$[2,100]$$N=100$$N$
• Anda tidak diizinkan untuk mengulang semua permutasi yang mungkin dengan penghitung, karena itu tidak akan pernah menghasilkan apa pun dalam jumlah waktu yang wajar. Hanya penerapan formula (salah satu dari tiga yang disediakan, turunan dari salah satu dari itu, atau formula yang sama sekali baru), atau metode lain yang akan memberikan hasil yang benar dalam jumlah waktu yang wajar (tanpa tentu saja hard-coding tentu saja ) Diperbolehkan. Saya berpikir tentang menambahkan waktu terbatas untuk memberlakukan ini, tapi saya pribadi menentang waktu terbatas dalam kombinasi dengan kode-golf , jadi saya tidak akan melakukannya. Tetap saja, pastikan program Anda memberikan jawaban, dan jika terlalu lambat untuk TIO karena alasan tertentu, tambahkan beberapa tangkapan layar dengan output dari mesin lokal Anda sebagai verifikasi.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa yang bukan kode. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
• Celah default tidak diperbolehkan.
• Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

Di sini kasus uji untuk dalam kisaran (jangan ragu untuk menggunakan tautan WolframAlpha di atas untuk kasus uji yang lebih besar):$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

CATATAN: Karena ini adalah tantangan kode-golf , pada dasarnya bermuara pada: mengimplementasikan salah satu dari tiga rumus ini (atau turunan / metode Anda sendiri yang masih menghasilkan hasil yang benar) sesingkat mungkin.

Bahasa Wolfram (Mathematica) , 59 byte

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

Cobalah online!

menggunakan algoritma Herbert Kociemba yang ditemukan di halaman OEIS

di sini adalah rumus rekursif:
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 byte disimpan oleh @Peter Taylor

satu byte lagi disimpan oleh @Expired Data

kode mesin x86, 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

Fungsi menerima jumlah ndalam ecx, dan pointer ke string untuk mengisi edx(yaitu fastcallkonvensi).

Sebelum saya menunjukkan kode sumber, beberapa penjelasan tentang bagaimana melakukan hal itu. Ini menggunakan rumus rekursif, yang saya tulis dengan cara berikut:

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

Jadi semua kode yang harus dilakukan adalah perkalian dengan angka kecil. Jumlahnya berada di kisaran 6 ... 36, yang cukup kecil untuk diwakili dalam bitmap 32-bit. Saya sebenarnya tidak menyimpan bit yang mewakili perkalian dengan 6 - ini memungkinkan saya mengatur kode dalam satu do-whilelingkaran, dimulai dengan perkalian tanpa syarat dengan 6.

Angka-angka besar diwakili menggunakan bentuk desimal - setiap byte adalah nilai dalam rentang 0 ... 9, mulai dari MSB.

Perkalian dilakukan dari LSB ke MSB; itu mengasumsikan bahwa jumlah digit akan bertambah 2 untuk setiap perkalian. Setelah melakukan perkalian dengan faktor kecil seperti 6, jumlah digit dapat tumbuh hanya 1. Jadi, jika MSB = 0, itu akan memindahkan seluruh hasil antara yang tersisa. Dapat benar-benar terjadi bahwa jumlah digit tidak tumbuh sama sekali, dan kemudian MSB akan tetap 0, tetapi masalah ini akan memperbaiki dirinya sendiri ketika kode berlanjut ke faktor yang lebih besar.

Karena kode multiplikasi besar, saya tidak ingin memasukkannya dua kali. Saya juga tidak ingin memindahkannya ke suatu fungsi, karena kode mesin untuk memanggil suatu fungsi besar. Jadi saya mengatur ulang loop luar sedemikian rupa sehingga kode pengali hanya diperlukan sekali.

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

Membongkar:

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;

Waktu berjalan untuk n = 100 adalah sekitar 4 detik, dan hasilnya adalah angka dengan 38416 digit:

23491019577617 (banyak digit di sini) ... (banyak nol di sini) 000000000000000000

05AB1E , 38 byte

Upaya awal.
Menggunakan Formula Chris Hardwick .
Akan berusaha bermain golf lebih jauh dan menjelaskan kapan saya punya waktu.

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

Cobalah online!

Julia 1.0 , 83 76 byte

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

Cobalah online!

Menggunakan Formula Chris Hardwick. Mengambil input sebagai bilangan bulat besar.

Terima kasih kepada H.PWiz untuk -7 byte

Python 2 , 72 byte

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

Cobalah online!

Disimpan 4 byte dengan menyalin n*(n-2)/4dari Neil .

Bahasa Wolfram (Mathematica) , 67 byte

Menggunakan Formula Chris Hardwick.

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

Cobalah online!

JavaScript (Node.js) , 81 byte

Formula rekursif Herbert Kociemba. Mengambil BigInt sebagai input.

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

Cobalah online!

---

JavaScript (Node.js) ,  102 98  96 byte

Formula Chris Hardwick. Mengambil BigInt sebagai input.

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

Cobalah online!

JavaScript (Node.js) , 77 75 73 byte

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

Cobalah online! Berdasarkan formula Christopher Mowla. Mengambil BigInt sebagai input. Uji harness tanpa malu-malu dicuri dari @Arnauld 0xb88d4641131f0nadalah 3246670537110000ndalam desimal. Penjelasan: Saya mulai dengan eksponen utama terakhir dan menyederhanakannya n*(n-2n)/4n(ini adalah pembagian bilangan bulat, jadi saya tidak perlu penyesuaian untuk angka ganjil). Saya kemudian memeriksa bilangan prima lainnya untuk melihat apakah eksponen mereka terkait dengan nilai ini (yang akan saya sebut sebagai o), dan menemukan bahwa mereka mengejar mode, jika saya mengizinkan penggunaan paritas n(yang saya sebut sebagai p). Rumus untuk eksponen adalah sebagai berikut:

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

Kekuatan kemudian dapat dikelompokkan berdasarkan eksponen jadi misalnya padalah eksponen 11*7*5**2*3**3*2**14.

Racket , 151 141 byte

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

Cobalah online!

Jawaban terpanjang menggunakan Formula Chris Hardwick :)

Python 2 , 122 byte

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)

Cobalah online!

Menggunakan metode rekursif Herbert Kociemba.

-2 byte terima kasih kepada Herman L

Jelly ,  39  38 byte

^{Saya merasa seperti melewatkan beberapa golf, tapi ...}

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

Tautan monadik yang menerapkan Formula Chris Hardwick.

Cobalah online! Atau lihat test-suite (n=[1..33]).

CJam (47 byte)

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

Jelly , 43 byte

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

Cobalah online!

Ikon , 125 110 byte

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

Cobalah online!

C (gcc) -lgmp, 279 byte

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

Cobalah online!

Perl 6 , 85 byte

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

Cobalah online!

Haskell , 86 85 74 byte

^{-1 byte disimpan berkat H.PWiz
-11 byte yang disimpan berkat 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)

Cobalah online!

Python 2 , 92 byte

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

Cobalah online!

Sekam , 51 48 44 byte

-4 byte terima kasih kepada H.PWiz

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

Cobalah online!

Ini adalah Formula Chris Hardwick. Juga, ini adalah program kulit pertama saya, jadi tips apa pun akan sangat dihargai.

C ++, 187 185 180 176 195 (ada bug) 193 175 bytes (dengan bantuan dari ceiling cat)

Ini menggunakan pembungkus GMP C ++ (GNU multi-precision library), dan formula yang digunakan oleh @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Gunakan g++ -g rubix.cpp -lgmp -lgmpxxuntuk mengkompilasi dan menautkan

#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, dengan kode uji

#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 byte , (tidak bersaing)

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

Ekspresi yang menerima input sebagai integer aktif Ans. Penerapan formula Chris Hardwick. Tidak bersaing karena perangkat keras yang dijalankannya hanya akan menyimpan hingga 16 desimal, jadi jawabannya tidak akan pernah 100% akurat.

Penjelasan:

{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