Giriş:

3x3x3 Rubik Küpü muhtemel permütasyona sahiptir ve yaklaşık 43 katrilyondur . Bu numarayı daha önce duymuş olabilirsiniz, ancak gerçekte nasıl hesaplanır?$43,252,003,274,489,856,000$

3x3x3 Rubik Küp, her biri dokuz çıkartma içeren altı yüze sahiptir. Çıkartmalar yerine (dış) parçalara baktığımızda, altı merkez parçamız var; sekiz köşe parçası; ve on iki kenar parçası. Merkezler taşınamadığı için hesaplamalarda bulunanları görmezden gelebiliriz. Köşeler ve kenarlar gelince:

• Orada( ) sekiz köşeyi düzenleme yolları. Her köşenin üç olası yönü vardır, ancak yalnızca yedi (sekiz) bağımsız olarak yönlendirilebilir; sekizinci / son köşenin oryantasyonu, önceki yedi, ( ) olasılıkları göz önüne alındığında bağlıdır .$8!$$40,320$$3^7$$2,187$
• Orada ( oniki kenarları düzenlemek için) yolları. yarıyaçünkü kenarlar her zaman tam olarak köşeler tam olarak eşit bir permütasyonda olmalıdır . Onbir kenar, ( ) olasılık göz önüne alındığında, önceki on birine bağlı olarak onikinci / son kenarın çevrilmesiyle bağımsız olarak .$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Bunu bir araya getirmek için aşağıdaki formüle sahibiz:

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

^{Kaynak: Wikipedia - Rubik Küp Permütasyonları}

Bu zaten oldukça karmaşık görünse de, 3x3x3 Küp için hala oldukça yalındır. Küpler için bile formül biraz farklıdır; Bu, örneğin 4x4x4 küp için bir formüldür:

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

Kısa ölçekte yaklaşık 7,40 katrilyon birimdir .

Ve daha büyük NxNxN Küpleri için (yani, şu anki Dünya Rekoru 33x33x33) formülü biraz uzatılacak. Bununla birlikte, bu girişi çok uzun sürmemesi için, yerine 4x4x4 Küp ve diğer bazı NxNxN Küplerin permütasyonlarının sonuçlanan bir formülle açıklandığı bu bağlantıları buraya koydum:

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

Şimdi merak ediyor olabilirsiniz: Herhangi bir x x Küp için dayalı genel bir formül var mı? Kesinlikle var. İşte tamamen dayalı üç aynı sonuçlar veren tamamen farklı üç algoritmalar :$N$$N$$N$$N$$N$

1: Chris Hardwick'in Formülü:

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

WolframAlpha'da dene.

2: Christopher Mowla'nın trig formülü:

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

WolframAlpha'da dene.

3: Christopher Mowla'nın ilkeleri Formül:

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

burada olan .$96577$$(13×17×19×23)$

WolframAlpha'da dene.

^{Kaynak: Cubers-reddit - Pozisyon Sayısının, Tanrı'nın Sayısının vb. Matematiksel Sayma Formülleri}

Meydan okuma:

aralığında bir giriş tamsayı verilmiş olan bu üç formülden birini (veya kendi türevinizi) seçin ve uygulayın , doğru sonucu verir.$N$$[2,100]$

Meydan okuma kuralları:

• Bu üçün yanında başka bir formül kullanmakta özgürsünüz, ancak bu üçünün doğru olduğunu kanıtladığınızı unutmayın. Başka bir formül kullanıyorsanız, lütfen nereden aldığınızı gösteren bir bağlantı ekleyin (veya kendiniz ile ilgili derinlemesine bir açıklama ekleyin). Çıktı doğruysa, aralıktaki tüm tamsayıları kontrol edeceğim. A075152: Belki bu dizi için oeis'te ilham bulunabilir .
• otomatik olarak bilimsel bir çıktı verirse (yani , 4x4x4 formülünden sonraki sayı yerine ) buna izin verilir. Ancak, bu bilimsel yuvarlamayı kesin bir çıktıya dönüştürmek için lütfen cevabınıza ek kod ekleyin, böylece sonuçlar doğrulanabilir, çünkü kodunuzda formülün yürütülmesi sırasında kayan nokta hassasiyetinden kaynaklanan yuvarlama hataları nedeniyle izin verilmez - gerçek sonuç, kesin.$1.401...×10^{45}$
• Programınız / işleviniz, en azından aralığındaki girişler için doğru olmalıdır ( zaten devasa bir sayıyla sonuçlandığından, daha büyük bir , muhtemelen bu sorunu çözebiliyorsanız çalışacaktır. bir doğru).$[2,100]$$N=100$$N$
• Bir sayaç ile olası tüm permütasyonları geçmenize izin verilmez, çünkü bu makul bir sürede hiçbir şey vermez. Yalnızca bir formülün (sağlanan üç taneden biri, bunlardan birinin bir türevi veya tamamen yeni bir formülün) uygulanması veya makul bir sürede (elbette zor kodlama olmadan) doğru sonuçları verecek başka bir yöntem ) izin verilir. Bunu zorlamak için sınırlı bir süre eklemeyi düşündüm , ama şahsen kısıtlı süreye karşı kod-golf ile birleşiyorum , bu yüzden yapmayacağım. Yine de, lütfen programınızın cevapları verdiğinden emin olun ve bir nedenden ötürü TIO için çok yavaşsa, doğrulama için yerel makinenizin çıktısıyla bazı ekran görüntüleri ekleyin.

Genel kurallar:

• Bu kod golf , bayt cinsinden en kısa cevap kazanır.
  Code-golf dillerinin, codegolfing olmayan dillerle cevap göndermekten vazgeçmesine izin vermeyin. Herhangi bir programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Standart G / Ç kurallarına cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT işlevlerini, uygun parametreleri içeren fonksiyonlar / yöntemleri ve dönüş tipini, tam programları kullanmanıza izin verilir. Senin çağrı.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuzu test eden bir bağlantı ekleyin (ör. TIO ).
• Ayrıca, cevabınız için bir açıklama eklemek şiddetle tavsiye edilir.

Test durumları:

Burada aralığında test durumları (daha büyük test durumları için yukarıdaki WolframAlpha linklerini kullanmaktan çekinmeyin):$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

NOT: Bu bir kod golfü mücadelesi olduğundan, temelde aşağıdakilere dayanır: Bu üç formülden birini (veya bir türev / hala doğru sonuçları üreten kendi yönteminizi) uygulayın.

Wolfram Dili (Mathematica) , 59 bayt

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

Çevrimiçi deneyin!

Herbert Kociemba'nın OEIS sayfasında bulunan algoritmasını kullanıyor

özyinelemeli formül İşte:
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)

@Peter Taylor tarafından kaydedilen 6 bayt

@Expired Data tarafından kaydedilen bir bayt daha

x86 makine kodu, 119 bayt

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

Fonksiyon numarası alır niçinde ecxve doldurmak için bir dizgeye bir işaretçi edx(örneğin, fastcallKongre).

Kaynak kodu göstermeden önce, işin nasıl yapıldığına dair bazı açıklamalar. Aşağıdaki şekilde yazdığım özyinelemeli formülü kullanır:

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

Bu yüzden kodun tek yapması gereken küçük sayılarla çarpmak. Rakamlar 6 ... 36 arasındadır ve bu, 32 bitlik bir bitmap'te gösterilecek kadar küçüktür. Aslında, çarpımı 6 ile temsil eden biti saklamıyorum - bu do-while, koşulsuz çarpma ile başlayan 6 ile kodu bir döngüde düzenlememe izin veriyor .

Büyük sayılar, ondalık form kullanılarak gösterilir - her bir bayt, MSB'den başlayarak 0 ... 9 aralığında bir değerdir.

Çarpma, LSB'den MSB'ye; Her çarpma için hane sayısının 2 artacağını varsayar. 6 gibi küçük bir faktörle çarpma işleminden sonra, hanelerin sayısı sadece 1 artabilir. Yani, eğer MSB = 0 ise, tüm ara sonucu sola kaydırır. Aslında rakamların sayısı hiç artmaz ve MSB hala 0 olur, ancak kod daha büyük faktörlere ilerlerken bu sorun kendiliğinden çözülür.

Çarpma kodu büyük olduğundan, iki kere koymak istemiyorum. Ben de bir işleve taşımak istemiyorum çünkü bir işlevin çağrılması için kullanılan makine kodu büyük. Böylece dış döngüleri çarpım koduna sadece bir kez ihtiyaç duyulacak şekilde yeniden düzenledi.

C kodu:

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

demontaj:

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;

N = 100 için çalışma süresi yaklaşık 4 saniyedir ve sonuç 38416 basamaklı bir sayıdır:

23491019577617 (buradaki birçok rakam) ... (buradaki birçok sıfır) 0000000000000000

05AB1E , 38 bayt

İlk deneme Chris Hardwick'in Formülünü
kullanır . Daha fazla golf oynamaya çalışacağım ve vaktim olduğunda açıklayacağım.

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

Çevrimiçi deneyin!

Julia 1.0 , 83 76 bayt

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

Çevrimiçi deneyin!

Chris Hardwick'in Formülünü kullanır. Büyük tamsayı olarak girdi alır.

-7 baytlık H.PWiz'e teşekkürler

Python 2,72 bayt

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

Çevrimiçi deneyin!

Kopyalayarak 4 bayt Kaydedilen n*(n-2)/4gelen Neil .

Wolfram Dili (Mathematica) , 67 bayt

Chris Hardwick'in formülünü kullanarak.

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 81 bayt

Herbert Kociemba'nın özyinelemeli formülü. Giriş olarak bir BigInt alır.

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

Çevrimiçi deneyin!

---

JavaScript (Node.js) ,  102 98  96 bayt

Chris Hardwick'in formülü. Giriş olarak bir BigInt alır.

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

Çevrimiçi deneyin!

JavaScript (Node.js) , 77 75 73 bayt

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

Çevrimiçi deneyin! Christopher Mowla'nın formülüne dayanarak. Giriş olarak bir BigInt alır. @Arnauld'dan utanmadan çalınan test kablo demeti. 0xb88d4641131f0nolduğu 3246670537110000nondalık. Açıklama: Son üs üs ile başladım ve basitleştirdim n*(n-2n)/4n(bu tamsayı bölmeli, bu yüzden tek sayılar için ayarlamaya ihtiyacım yok). Sonra onların üsteller (Ben atıfta bulunacaktır bu değere ilişkili olup olmadığını görmek için diğer asal incelenmiş o) ve ben parite kullanılmasına izin takdirde, şöyle böyle olduğunu gördük nben atıfta bulunacaktır ( p). Üstler için formüller aşağıdaki gibidir:

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

Güçler daha sonra üs ile gruplandırılabilir, bu nedenle örneğin püsdür 11*7*5**2*3**3*2**14.

Raket , 151 141 bayt

Fede s sayesinde -7 bayt!

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

Çevrimiçi deneyin!

Chris Hardwick Formülünü kullanan en uzun cevap :)

Python 2 , 122 bayt

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)

Çevrimiçi deneyin!

Herbert Kociemba özyinelemeli yöntemi kullanır.

Herman L sayesinde -2 bayt

Jöle ,  39  38 bayt

^{Bazı golfleri kaçırdığımı hissediyorum, ama ...}

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

Chris Hardwick Formülünü uygulayan monadik bir Bağlantı.

Çevrimiçi deneyin! Veya test takımına bakın (n=[1..33]).

CJam (47 bayt)

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

Çevrimiçi demo

Bu, Herbert Kociemba'nın OEIS'den özdeyişini uygular: CJam en memoised kullanılarak özyineleme operatörü . MathJax bloğundaki terimleri koddakiyle aynı sırayla sipariş ettim; yazışmaların CJam'ı okuyanlar için doğrulamasını kolaylaştırmak için: başka bir diseksiyon daha fazla ışık tutamayacak.

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

Jöle , 43 bayt

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

Çevrimiçi deneyin!

Simge , 125 110 bayt

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

Çevrimiçi deneyin!

C (gcc) -lgmp, 279 bayt

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

Çevrimiçi deneyin!

Perl 6 , 85 bayt

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

Çevrimiçi deneyin!

Haskell , 86 85 74 bayt

^{Max Yekhlakov sayesinde kaydedilen H.PWiz -11 bayt sayesinde -1 bayt}

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)

Çevrimiçi deneyin!

Python 2 , 92 bayt

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

Çevrimiçi deneyin!

Husk , 51 48 44 bayt

H.PWiz sayesinde -4 bayt

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

Çevrimiçi deneyin!

Bu Chris Hardwick'in Formülü. Ayrıca, bu benim ilk kabuğu programı, bu yüzden herhangi bir ipucu iyi olurdu.

C ++, 187 185 180 176 195 (bir böcek vardı) 193 175 bayt (tavan kedisi yardımıyla)

Bu GMP C ++ sargısını (GNU çok hassas kütüphane) ve @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ) tarafından kullanılan formülü kullanır .

Kullanım g++ -g rubix.cpp -lgmp -lgmpxxderleme ve bağlantı

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

test kodu ile ungolfed

#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 bayt , (rekabetçi değil)

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

Tam sayı olarak girdi alan ifade Ans. Chris Hardwick'in formülünün uygulanması. Rekabet etmiyor çünkü çalıştığı donanım yalnızca 16 ondalık basamağa kadar depolayabiliyor, bu yüzden cevap% 100 kesin olmuyor.

Açıklama:

{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