บทนำ:

ลูกบาศก์รูบิค 3x3x3 มีพีชคณิตเป็นไปได้ซึ่งมีประมาณ 43 Quintillion คุณอาจเคยได้ยินเกี่ยวกับหมายเลขนี้มาก่อน แต่มันคำนวณได้อย่างไรจริง ๆ$43,252,003,274,489,856,000$

ลูกบาศก์รูบิค 3x3x3 มีหกด้านแต่ละด้านมีเก้าสติกเกอร์ ดูที่ชิ้นส่วนภายนอกแทนที่จะเป็นสติกเกอร์เรามีชิ้นกลางหกชิ้น แปดมุมชิ้น; และขอบชิ้นสิบสองชิ้น เนื่องจากศูนย์ไม่สามารถเคลื่อนย้ายได้เราจึงสามารถข้ามศูนย์เหล่านั้นในการคำนวณได้ สำหรับมุมและขอบ:

• มี( ) วิธีในการจัดเรียงมุมทั้งแปด แต่ละมุมมีทิศทางที่เป็นไปได้สามแบบแม้ว่าจะมีเพียงแค่เจ็ด (จากแปด) เท่านั้น การวางแนวของมุมที่แปด / สุดท้ายขึ้นอยู่กับเจ็ดก่อนหน้านี้ให้ความเป็นไปได้ ( )$8!$$40,320$$3^7$$2,187$
• มี ( ) วิธีในการจัดเรียงขอบทั้งสิบสอง ลดลงครึ่งหนึ่งจากเป็นเพราะขอบจะต้องอยู่ในการเปลี่ยนแปลงแม้แต่เมื่อมุมอยู่เสมอ สามารถพลิกขอบได้สิบเอ็ดอย่างอิสระโดยการพลิกของขอบที่สิบสอง / สุดท้ายขึ้นอยู่กับสิบเอ็ดก่อนหน้านี้ให้ความเป็นไปได้ ( )$\frac{12!}{2}$$239,500,800$$12!$2112,048$2^{11}$$2,048$

เมื่อรวมเข้าด้วยกันเรามีสูตรต่อไปนี้:

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

^{ที่มา: Wikipedia - รูบิคคิวบิคิว}

แม้ว่าสิ่งนี้อาจดูซับซ้อนอยู่แล้ว แต่มันก็ค่อนข้างตรงไปตรงมาสำหรับลูกบาศก์ 3x3x3 สำหรับแม้แต่ลูกบาศก์สูตรจะแตกต่างกันเล็กน้อย นี่เป็นสูตรสำหรับ Cube 4x4x4 เช่น:

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

ซึ่งจะอยู่ที่ประมาณ 7.40 quattuordecillion โยสั้น

และสำหรับก้อน NxNxN ขนาดใหญ่ (เช่นสถิติโลกปัจจุบัน 33x33x33) สูตรจะขยายออกไปเล็กน้อย เพื่อไม่ให้มีการแนะนำนี้นานเกินไปฉันใส่ลิงค์เหล่านี้ที่นี่แทนโดยที่การเรียงสับเปลี่ยนของ 4x4x4 Cube และก้อน NxNxN ขนาดอื่น ๆ ถูกอธิบายด้วยสูตรผลลัพธ์:

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

คุณอาจจะสงสัยโดยขณะนี้: มีสูตรทั่วไปตามที่สำหรับการใด ๆ x x Cube? มีอยู่อย่างแน่นอน ต่อไปนี้เป็นอัลกอริธึมที่แตกต่างกันสามแบบโดยสิ้นเชิงทั้งหมดล้วนให้ผลลัพธ์ที่เหมือนกันตาม :$N$$N$$N$$N$$N$

1: สูตรของ 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}}$$

ลองใช้กับ WolframAlpha

2: สูตร Trig ของ 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})}}$$

ลองใช้กับ WolframAlpha

3: สูตรเฉพาะของ 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)}$$

ที่เป็น23)$96577$$(13×17×19×23)$

ลองใช้กับ WolframAlpha

^{ที่มา: Cubers-reddit - สูตรการนับทางคณิตศาสตร์ของจำนวนตำแหน่งจำนวนพระเจ้า ฯลฯ}

ท้าทาย:

เลือกและใช้หนึ่งในสามสูตรเหล่านี้ (หรืออนุพันธ์ของคุณเอง) ซึ่งได้รับอินพุตจำนวนเต็มในช่วงผลลัพธ์ที่ถูกต้อง$N$$[2,100]$

กฏท้าทาย:

• คุณมีอิสระที่จะใช้สูตรอื่นนอกเหนือจากทั้งสามนี้ แต่โปรดจำไว้ว่าสามสูตรนี้ได้รับการพิสูจน์แล้วว่าถูกต้อง หากคุณใช้สูตรอื่นโปรดเพิ่มลิงก์ที่คุณได้รับจากสูตรนั้น (หรือถ้าคุณคิดสูตรเองเพิ่มคำอธิบายในเชิงลึก) และฉันจะตรวจสอบจำนวนเต็มทั้งหมดในช่วงถ้าผลลัพธ์ถูกต้อง บางทีอาจจะเป็นแรงบันดาลใจที่จะพบได้ในOEIS สำหรับลำดับนี้: A075152
• หากภาษาของคุณแสดงผลลัพธ์ทางวิทยาศาสตร์โดยอัตโนมัติ (เช่นแทนที่จะเป็นตัวเลขหลังจากสูตร 4x4x4) สิ่งนี้จะได้รับอนุญาต แต่โปรดเพิ่มรหัสเพิ่มเติมลงในคำตอบของคุณเพื่อแปลงการปัดเศษทางวิทยาศาสตร์นี้เป็นผลลัพธ์ที่แน่นอนเพื่อให้สามารถตรวจสอบผลลัพธ์ได้เนื่องจากข้อผิดพลาดในการปัดเศษเนื่องจากความแม่นยำจุดลอยตัวในระหว่างการดำเนินการสูตรในรหัสของคุณไม่อนุญาต แน่นอน$1.401...×10^{45}$
• โปรแกรม / ฟังก์ชั่นของคุณควรถูกต้องอย่างน้อยอินพุทในช่วง (แม้ว่าเนื่องจากส่งผลให้มีจำนวนตูดใหญ่แล้วใหญ่กว่าก็อาจทำงานได้เช่นกันถ้าคุณสามารถส่งออกได้ หนึ่งอย่างถูกต้อง)$[2,100]$$N=100$$N$
• คุณไม่ได้รับอนุญาตให้วนซ้ำกับการเรียงสับเปลี่ยนที่เป็นไปได้ทั้งหมดเนื่องจากตัวนับจะไม่ส่งออกอะไรในเวลาที่เหมาะสม มีเพียงการนำไปใช้งานของสูตร (อย่างใดอย่างหนึ่งในสามที่ให้ไว้, อนุพันธ์ของหนึ่งในนั้น, หรือสูตรใหม่อย่างสมบูรณ์) หรือวิธีการอื่นที่จะให้ผลลัพธ์ที่ถูกต้องในระยะเวลาที่เหมาะสม (โดยไม่มีการเข้ารหัสแน่นอน ) ได้รับอนุญาต. ฉันคิดถึงการเพิ่มเวลาที่จำกัด ในการบังคับใช้ แต่ฉันเป็นการส่วนตัวกับการจำกัด เวลาร่วมกับการเล่นกอล์ฟดังนั้นฉันจะไม่ทำ ยังโปรดตรวจสอบให้แน่ใจว่าโปรแกรมของคุณให้คำตอบและหาก TIO ช้าเกินไปด้วยเหตุผลบางประการให้เพิ่มภาพหน้าจอบางส่วนที่มีเอาต์พุตจากเครื่องท้องถิ่นของคุณเป็นการยืนยัน

กฎทั่วไป:

• นี่คือcode-golfดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
  อย่าปล่อยให้ภาษาโค้ดกอล์ฟกีดกันคุณจากการโพสต์คำตอบด้วยภาษาที่ไม่ได้เข้ารหัส พยายามหาคำตอบสั้น ๆ ที่เป็นไปได้สำหรับภาษาโปรแกรม 'ใด ๆ '
• กฎมาตรฐานใช้สำหรับคำตอบของคุณด้วยกฎ I / O เริ่มต้นดังนั้นคุณจึงได้รับอนุญาตให้ใช้ STDIN / STDOUT ฟังก์ชั่น / วิธีพร้อมพารามิเตอร์ที่เหมาะสมและประเภทผลตอบแทนโปรแกรมเต็มรูปแบบ การโทรของคุณ
• ช่องโหว่เริ่มต้นเป็นสิ่งต้องห้าม
• หากเป็นไปได้โปรดเพิ่มลิงก์พร้อมทดสอบรหัสของคุณ (เช่นTIO )
• นอกจากนี้ขอแนะนำให้เพิ่มคำอธิบายสำหรับคำตอบของคุณ

กรณีทดสอบ:

ที่นี่กรณีทดสอบสำหรับอยู่ในช่วง (ลังเลที่จะใช้ลิงก์ WolframAlpha ด้านบนสำหรับกรณีทดสอบขนาดใหญ่):$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

หมายเหตุ: เนื่องจากนี่เป็นความท้าทายของการเล่นกอล์ฟจึงจำเป็นต้องใช้สูตรหนึ่งในสามสูตรนี้ (หรืออนุพันธ์ / วิธีการของคุณเองที่ยังคงให้ผลลัพธ์ที่ถูกต้อง) โดยย่อ

ภาษา Wolfram (Mathematica) , 59 ไบต์

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

ลองออนไลน์!

ใช้อัลกอริทึมของ Herbert Kociemba ที่พบในหน้า OEIS

นี่คือสูตรแบบเรียกซ้ำ:
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 ไบต์โดย @Peter Taylor

บันทึกอีกหนึ่งไบต์โดย @Expired Data

รหัสเครื่อง x86, 119 ไบต์

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

ฟังก์ชั่นได้รับจำนวนnในecxและชี้ไปยังสตริงเพื่อเติมในedx(เช่นfastcallการประชุม)

ก่อนที่ฉันจะแสดงซอร์สโค้ดมีคำอธิบายบางอย่างเกี่ยวกับวิธีการทำงาน มันใช้สูตรแบบเรียกซ้ำซึ่งฉันเขียนด้วยวิธีต่อไปนี้:

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

ดังนั้นรหัสทั้งหมดควรทำคือการคูณด้วยจำนวนน้อย ตัวเลขอยู่ในช่วง 6 ... 36 ซึ่งมีขนาดเล็กพอที่จะแสดงในบิตแมปแบบ 32 บิต จริง ๆ แล้วฉันไม่ได้เก็บบิตซึ่งแสดงถึงการคูณด้วย 6 - นี่ช่วยให้ฉันจัดเรียงรหัสในการdo-whileวนเริ่มต้นด้วยการคูณที่ไม่มีเงื่อนไขโดย 6

ตัวเลขขนาดใหญ่จะแสดงโดยใช้รูปแบบทศนิยม - แต่ละไบต์เป็นค่าในช่วง 0 ... 9 เริ่มต้นจาก MSB

การคูณจะดำเนินการจาก LSB ถึง MSB สมมติว่าจำนวนหลักจะเพิ่มขึ้น 2 สำหรับการคูณแต่ละครั้ง หลังจากทำการคูณด้วยปัจจัยเล็ก ๆ เช่น 6 จำนวนหลักอาจเพิ่มขึ้นเพียง 1 ดังนั้นถ้า MSB = 0 มันจะย้ายผลลัพธ์กลางทั้งหมดที่เหลือ มันสามารถเกิดขึ้นได้จริงว่าจำนวนหลักไม่เพิ่มขึ้นเลยจากนั้น MSB จะยังคงเป็น 0 แต่ปัญหานี้จะแก้ไขตัวเองเมื่อรหัสดำเนินการเพื่อปัจจัยที่มากขึ้น

เนื่องจากรหัสการคูณมีขนาดใหญ่ฉันไม่ต้องการใส่สองครั้ง ฉันไม่ต้องการย้ายไปยังฟังก์ชั่นอย่างใดอย่างหนึ่งเพราะรหัสเครื่องสำหรับการเรียกใช้ฟังก์ชั่นมีขนาดใหญ่ ดังนั้นฉันจึงจัดเรียงลูปด้านนอกใหม่ในลักษณะที่ต้องใช้รหัสการคูณเพียงครั้งเดียว

รหัส 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';
    }
}

ถอดชิ้นส่วน:

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 คือประมาณ 4 วินาทีและผลลัพธ์คือตัวเลขที่มี 38416 หลัก:

23491019577617 (ตัวเลขหลายหลักตรงนี้) ... (ศูนย์จำนวนมากที่นี่) 0000000000000000

05AB1E , 38 ไบต์

ความพยายามครั้งแรก
ใช้สูตรคริสฮาร์ดวิคของ
จะพยายามตีกอล์ฟต่อไปและอธิบายเมื่อฉันมีเวลา

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

ลองออนไลน์!

Julia 1.0 , 83 76 ไบต์

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

ลองออนไลน์!

ใช้สูตรของ Chris Hardwick รับอินพุตเป็นจำนวนเต็มขนาดใหญ่

ขอบคุณ H.PWiz สำหรับ -7 ไบต์

Python 2 , 72 ไบต์

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

ลองออนไลน์!

ที่บันทึกไว้ 4 ไบต์โดยการคัดลอกn*(n-2)/4จากนีล

ภาษา Wolfram (Mathematica) , 67 ไบต์

ใช้สูตรของ Chris Hardwick

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

ลองออนไลน์!

JavaScript (Node.js) , 81 ไบต์

สูตรซ้ำของ Herbert Kociemba ใช้ BigInt เป็นอินพุต

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

ลองออนไลน์!

---

JavaScript (Node.js) ,  102 98  96 ไบต์

สูตรของ Chris Hardwick ใช้ BigInt เป็นอินพุต

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

ลองออนไลน์!

JavaScript (Node.js) , 77 75 73 ไบต์

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

ลองออนไลน์! ขึ้นอยู่กับสูตรของ Christopher Mowla ใช้ BigInt เป็นอินพุต สายรัดทดสอบถูกขโมยอย่างไร้ตำหนิจาก @Arnauld 0xb88d4641131f0nเป็น3246670537110000nทศนิยม คำอธิบาย: ฉันเริ่มต้นด้วยเลขชี้กำลังสุดท้ายที่สำคัญและทำให้มันง่ายขึ้นn*(n-2n)/4n(นี่คือการหารจำนวนเต็มดังนั้นฉันไม่ต้องการการปรับสำหรับเลขคี่) จากนั้นฉันตรวจสอบจำนวนเฉพาะอื่น ๆ เพื่อดูว่าตัวแทนของพวกเขาเกี่ยวข้องกับค่านี้ (ซึ่งฉันจะเรียกว่าเป็นo) และพบว่าพวกเขาอยู่หลังแฟชั่นถ้าฉันอนุญาตให้ใช้ความเท่าเทียมกันของn(ซึ่งฉันจะเรียกว่าp) สูตรสำหรับเลขชี้กำลังมีดังนี้:

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

อำนาจนั้นจะสามารถจัดกลุ่มตามสัญลักษณ์ดังนั้นสำหรับตัวอย่างที่เป็นตัวแทนของp11*7*5**2*3**3*2**14

แร็กเก็ต , 151 141 ไบต์

-7 ไบต์ขอบคุณ 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))))

ลองออนไลน์!

คำตอบที่ยาวที่สุดโดยใช้สูตรของ Chris Hardwick :)

Python 2 , 122 ไบต์

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)

ลองออนไลน์!

ใช้วิธีเรียกซ้ำของ Herbert Kociemba

-2 ไบต์ขอบคุณ Herman L

เจลลี่ ,  39  38 ไบต์

^{ฉันรู้สึกเหมือนฉันพลาดสนามกอล์ฟ แต่ ...}

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

Monadic Link ใช้สูตรของ Chris Hardwick

ลองออนไลน์! หรือดูชุดทดสอบ (n=[1..33])

CJam (47 ไบต์)

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

การสาธิตออนไลน์

สิ่งนี้ใช้การเรียกซ้ำของ Herbert Kociemba จาก OEIS: โดยใช้บันทึกของ CJam ผู้ประกอบการเรียกซ้ำ ฉันได้รับคำสั่งในบล็อก MathJax ตามลำดับเช่นเดียวกับในรหัสเพื่อให้การติดต่อนั้นง่ายต่อการตรวจสอบสำหรับผู้ที่อ่าน CJam: การผ่าเพิ่มเติมใด ๆ จะไม่ทำให้กระจ่างมากขึ้น

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

เยลลี่ 43 ไบต์

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

ลองออนไลน์!

ไอคอน , 125 110 ไบต์

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

ลองออนไลน์!

C (gcc) -lgmp, 279 ไบต์

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

ลองออนไลน์!

Perl 6 , 85 ไบต์

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

ลองออนไลน์!

Haskell , 86 85 74 ไบต์

^{-1 ไบต์บันทึกขอบคุณ H.PWiz
-11 ไบต์บันทึกขอบคุณ 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)

ลองออนไลน์!

Python 2 , 92 ไบต์

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

ลองออนไลน์!

Husk , 51 48 44 ไบต์

-4 ไบต์ขอบคุณ H.PWiz

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

ลองออนไลน์!

นี่คือสูตรของ Chris Hardwick นอกจากนี้ยังเป็นโปรแกรมแรกของฉันดังนั้นเคล็ดลับใด ๆ ที่จะได้รับการชื่นชมอย่างดี

C ++, 187 185 180 176 195 (มีข้อผิดพลาด) 193 175 ไบต์ (ด้วยความช่วยเหลือจากแมวเพดาน)

สิ่งนี้ใช้ wrapper GMP C ++ (ไลบรารีความแม่นยำแบบมัลติ GNU) และสูตรที่ใช้โดย @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 )

ใช้g++ -g rubix.cpp -lgmp -lgmpxxในการรวบรวมและลิงค์

#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 ด้วยรหัสทดสอบ

#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 ไบต์ , (ไม่ใช่การเข้ารหัส)

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

Ansการแสดงออกซึ่งจะมีการป้อนข้อมูลเป็นจำนวนเต็มบน การใช้สูตรของ Chris Hardwick การไม่คอมไพล์เนื่องจากฮาร์ดแวร์ที่ทำงานอยู่จะเก็บได้ถึงตำแหน่งทศนิยม 16 ตำแหน่งเท่านั้นดังนั้นคำตอบจะไม่ถูกต้อง 100%

คำอธิบาย:

{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