Giới thiệu:

Một khối Rubik có hoán vị có thể, tương đương khoảng 43 triệu . Bạn có thể đã nghe về con số này trước đây, nhưng nó thực sự được tính như thế nào?$43,252,003,274,489,856,000$

Một khối Rubik 3x3x3 có sáu mặt, mỗi mặt có chín miếng dán. Tuy nhiên, nhìn vào các mảnh (bên ngoài) thay vì nhãn dán, chúng ta có sáu mảnh trung tâm; tám góc mảnh; và mười hai mảnh cạnh. Vì các trung tâm không thể được di chuyển, chúng tôi có thể bỏ qua những người trong tính toán. Đối với các góc và cạnh:

• Có( ) cách sắp xếp tám góc. Mỗi góc có ba hướng có thể, mặc dù chỉ có bảy (trong số tám) có thể được định hướng độc lập; định hướng của góc thứ tám / cuối cùng phụ thuộc vào bảy trước, cho ( ) khả năng.$8!$$40,320$$3^7$$2,187$
• Có ( ) cách sắp xếp mười hai cạnh. Một nửa từlà bởi vì các cạnh phải luôn luôn nằm trong một hoán vị chính xác khi các góc. Mười một cạnh có thể được lật độc lập, với việc lật cạnh thứ mười hai / cuối cùng tùy thuộc vào mười một trước đó, đưa ra ( ) khả năng.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Đặt điều này cùng nhau, chúng ta có công thức sau đây:

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

^{Nguồn: Wikipedia - Hoán vị khối Rubik}

Mặc dù điều này có thể trông khá phức tạp, nhưng nó vẫn khá đơn giản đối với Cube 3x3x3. Đối với các hình khối chẵn, công thức hơi khác nhau; đây là công thức cho một khối 4x4x4 chẳng hạn:

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

Đó là khoảng 7,40 quattuordecillion trên quy mô ngắn .

Và đối với các khối NxNxN lớn hơn (tức là Kỷ lục thế giới 33x33x33 hiện tại), công thức sẽ được mở rộng khá nhiều. Tuy nhiên, để không giới thiệu quá lâu, tôi đã đặt các liên kết này ở đây, trong đó các hoán vị của Khối 4 x 4 và một số khối NxNxN có kích thước khác được giải thích với một công thức kết quả:

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

Bây giờ bạn có thể tự hỏi: có một công thức chung dựa trên $N$ cho bất kỳ $N$ x $N$ x $N$ Cube nào không? Chắc chắn là có. Dưới đây là ba thuật toán hoàn toàn khác nhau, tất cả đều cho kết quả chính xác giống nhau dựa trên $N$ :

1: Công thức của 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}}$$

Hãy thử nó trên WolframAlpha.

2: Công thức trig của 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})}}$$

Hãy thử nó trên WolframAlpha.

3: Công thức nguyên tố của 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)}$$

trong đó $96577$ là $(13×17×19×23)$ .

Hãy thử nó trên WolframAlpha.

^{Nguồn: Cubers-reddit - Công thức đếm toán học về số lượng vị trí, số lượng của Chúa, v.v.}

Thử thách:

Chọn và thực hiện một trong ba công thức này (hoặc đạo hàm của riêng bạn), đưa ra một số nguyên $N$ vào trong phạm vi $[2,100]$ , đưa ra kết quả chính xác.

Quy tắc thử thách:

• Bạn có thể tự do sử dụng một công thức khác ngoài ba công thức này, nhưng hãy nhớ rằng ba công thức này được chứng minh là đúng. Nếu bạn sử dụng một công thức khác, vui lòng thêm một liên kết về nơi bạn đã nhận nó (hoặc nếu bạn tự mình đưa ra một lời giải thích sâu sắc). Và tôi sẽ kiểm tra tất cả các số nguyên trong phạm vi nếu đầu ra là chính xác. Có lẽ cảm hứng có thể được tìm thấy trong oeis cho chuỗi này: A075152 .
• Nếu ngôn ngữ của bạn tự động xuất ra một đầu ra khoa học (tức là $1.401...×10^{45}$ thay vì số sau công thức 4x4x4) thì điều này được cho phép. Nhưng vui lòng thêm mã bổ sung vào câu trả lời của bạn để chuyển đổi làm tròn khoa học này thành đầu ra chính xác để có thể xác minh kết quả, vì các lỗi làm tròn do độ chính xác của dấu phẩy động trong quá trình thực thi công thức trong mã của bạn là không được phép - kết quả thực tế phải là chính xác.
• Chương trình / chức năng của bạn phải chính xác cho ít nhất các đầu vào trong phạm vi $[2,100]$ (mặc dù, vì $N=100$ đã dẫn đến một số lượng lớn, bất kỳ $N$ lớn nào cũng có thể hoạt động tốt nếu bạn có thể đầu ra này một cách chính xác).
• Bạn không được phép lặp lại tất cả các hoán vị có thể có với một bộ đếm, vì điều đó sẽ không bao giờ xuất ra bất cứ thứ gì trong một khoảng thời gian hợp lý. Chỉ thực hiện một công thức (một trong ba công thức được cung cấp, một dẫn xuất của một trong số đó, hoặc một công thức hoàn toàn mới) hoặc một phương pháp khác sẽ cho kết quả chính xác trong một khoảng thời gian hợp lý (tất nhiên không cần mã hóa cứng ) được cho phép. Tôi đã nghĩ về việc thêm thời gian hạn chế để thực thi điều này, nhưng cá nhân tôi chống lại thời gian hạn chế kết hợp với môn đánh gôn , vì vậy tôi sẽ không. Tuy nhiên, vui lòng đảm bảo rằng chương trình của bạn đưa ra câu trả lời và vì lý do nào đó quá chậm đối với TIO vì một số lý do, hãy thêm một số ảnh chụp màn hình với đầu ra từ máy cục bộ của bạn để xác minh.

Quy tắc chung:

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.
  Đừng để ngôn ngữ mã-golf ngăn cản bạn đăng câu trả lời với các ngôn ngữ không mã hóa. Cố gắng đưa ra một câu trả lời càng ngắn càng tốt cho ngôn ngữ lập trình 'bất kỳ'.
• Quy tắc chuẩn áp dụng cho câu trả lời của bạn với quy tắc I / O mặc định , vì vậy bạn được phép sử dụng STDIN / STDOUT, các hàm / phương thức với các tham số thích hợp và kiểu trả về, chương trình đầy đủ. Cuộc gọi của bạn.
• Lỗ hổng mặc định bị cấm.
• Nếu có thể, vui lòng thêm một liên kết với một bài kiểm tra cho mã của bạn (ví dụ TIO ).
• Ngoài ra, thêm một lời giải thích cho câu trả lời của bạn rất được khuyến khích.

Các trường hợp thử nghiệm:

Ở đây các trường hợp thử nghiệm cho $N$ trong phạm vi $[2,10]$ (vui lòng sử dụng các liên kết WolframAlpha ở trên cho các trường hợp thử nghiệm lớn hơn):

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

LƯU Ý: Vì đây là một thử thách chơi gôn , về cơ bản, nó tập trung vào: thực hiện một trong ba công thức này (hoặc một công cụ phái sinh / phương pháp của riêng bạn mà vẫn tạo ra kết quả chính xác) càng ngắn càng tốt.

Ngôn ngữ Wolfram (Mathicala) , 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

Hãy thử trực tuyến!

sử dụng thuật toán của Herbert Kociemba được tìm thấy trong trang OEIS

đây là công thức đệ quy:
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 được lưu bởi @Peter Taylor

thêm một byte được lưu bởi @Expired Data

mã máy 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

Hàm nhận được số ntrong ecxvà một con trỏ tới một chuỗi để điền vào edx(tức là fastcallquy ước).

Trước khi tôi hiển thị mã nguồn, một số giải thích về cách thực hiện. Nó sử dụng công thức đệ quy, mà tôi đã viết theo cách sau:

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

Vì vậy, tất cả các mã nên làm là nhân với số lượng nhỏ. Các số nằm trong phạm vi 6 ... 36, đủ nhỏ để được biểu thị trong bitmap 32 bit. Tôi thực sự không lưu trữ bit đại diện cho phép nhân với 6 - điều này cho phép tôi sắp xếp mã theo do-whilevòng lặp, bắt đầu bằng phép nhân vô điều kiện với 6.

Các số lớn được biểu diễn bằng dạng thập phân - mỗi byte là một giá trị trong phạm vi 0 ... 9, bắt đầu từ MSB.

Phép nhân được thực hiện từ LSB đến MSB; nó giả định rằng số chữ số sẽ tăng thêm 2 cho mỗi phép nhân. Sau khi thực hiện phép nhân với một yếu tố nhỏ như 6, số chữ số có thể chỉ tăng thêm 1. Vì vậy, nếu MSB = 0, nó sẽ di chuyển toàn bộ kết quả trung gian sang trái. Thực tế có thể xảy ra rằng số chữ số hoàn toàn không tăng, và sau đó MSB vẫn sẽ là 0, nhưng vấn đề này sẽ tự khắc phục khi mã tiến hành các yếu tố lớn hơn.

Vì mã nhân lớn, tôi không muốn đặt mã hai lần. Tôi cũng không muốn chuyển nó sang một chức năng, bởi vì mã máy để gọi một chức năng là lớn. Vì vậy, tôi đã sắp xếp lại các vòng lặp bên ngoài theo cách mà mã nhân chỉ cần một lần.

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

Tháo gỡ:

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;

Thời gian chạy cho n = 100 là khoảng 4 giây và kết quả là một số có 38416 chữ số:

23491019577617 (nhiều chữ số ở đây) ... (nhiều số không ở đây) 0000000000000000

05AB1E , 38 byte

Nỗ lực ban đầu.
Sử dụng công thức của Chris Hardwick .
Sẽ cố gắng để chơi golf hơn nữa và giải thích khi tôi có thời gian.

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

Hãy thử trực tuyến!

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)

Hãy thử trực tuyến!

Sử dụng công thức của Chris Hardwick. Lấy đầu vào là số nguyên lớn.

Cảm ơn H.PWiz cho -7 byte

Python 2 , 72 byte

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

Hãy thử trực tuyến!

Đã lưu 4 byte bằng cách sao chép n*(n-2)/4từ Neil .

Ngôn ngữ Wolfram (Mathicala) , 67 byte

Sử dụng công thức của Chris Hardwick.

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 81 byte

Công thức đệ quy của Herbert Kociemba. Lấy một BigInt làm đầu vào.

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

Hãy thử trực tuyến!

---

JavaScript (Node.js) ,  102 98  96 byte

Công thức của Chris Hardwick. Lấy một BigInt làm đầu vào.

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 77 75 73 byte

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

Hãy thử trực tuyến! Dựa trên công thức của Christopher Mowla. Lấy một BigInt làm đầu vào. Khai thác thử nghiệm đáng xấu hổ bị đánh cắp từ @Arnauld. 0xb88d4641131f0nlà 3246670537110000nsố thập phân. Giải thích: Tôi đã bắt đầu với số mũ nguyên tố cuối cùng và đơn giản hóa nó thành n*(n-2n)/4n(đây là phép chia số nguyên, vì vậy tôi không cần điều chỉnh cho các số lẻ). Sau đó, tôi đã kiểm tra các số nguyên tố khác để xem liệu số mũ của chúng có liên quan đến giá trị này không (mà tôi sẽ đề cập đến o), và thấy rằng chúng thuộc về thời trang, nếu tôi cho phép sử dụng tính chẵn lẻ của n(mà tôi sẽ đề cập đến như p). Các công thức cho số mũ như sau:

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

Các quyền hạn sau đó có thể được nhóm theo số mũ, ví dụ như psố mũ của 11*7*5**2*3**3*2**14.

Vợt , 151 141 byte

-7 byte nhờ 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))))

Hãy thử trực tuyến!

Câu trả lời dài nhất sử dụng Công thức của 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)

Hãy thử trực tuyến!

Sử dụng phương pháp đệ quy Herbert Kociemba.

-2 byte nhờ Herman L

Thạch ,  39  38 byte

^{Tôi cảm thấy như tôi đã bỏ lỡ một số golf, nhưng ...}

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

Một liên kết đơn thể thực hiện Công thức của Chris Hardwick.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm (n=[1..33]).

CJam (47 byte)

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

Bản demo trực tuyến

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

Thạch , 43 byte

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

Hãy thử trực tuyến!

Biểu tượng , 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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Perl 6 , 85 byte

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

Hãy thử trực tuyến!

Haskell , 86 85 74 byte

^{-1 byte được lưu nhờ vào H.PWiz
-11 byte được lưu nhờ 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)

Hãy thử trực tuyến!

Python 2 , 92 byte

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

Hãy thử trực tuyến!

Husk , 51 48 44 byte

-4 byte nhờ H.PWiz

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

Hãy thử trực tuyến!

Đây là công thức của Chris Hardwick. Ngoài ra, đây là chương trình trấu đầu tiên của tôi, vì vậy bất kỳ lời khuyên nào cũng sẽ được đánh giá cao.

C ++, 187 185 180 176 195 (có lỗi) 193 175 byte (với sự trợ giúp từ mèo trần)

Công cụ này sử dụng trình bao bọc GMP C ++ (thư viện đa độ chính xác GNU) và công thức được sử dụng bởi @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Sử dụng g++ -g rubix.cpp -lgmp -lgmpxxđể biên dịch và liên kết

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

không có mã, với mã kiểm tra

#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 , (không lọc)

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

Biểu thức lấy đầu vào là một số nguyên trên Ans. Thực hiện công thức của Chris Hardwick. Không cấu hình vì phần cứng mà nó chạy sẽ chỉ lưu trữ tối đa 16 chữ số thập phân, vì vậy câu trả lời sẽ không bao giờ chính xác 100%.

Giải trình:

{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