소개:

3x3x3 루빅스 큐브가 약 43이다 가능한 순열, quintillion을 . 이 번호에 대해 들어 본 적이 있지만 실제로 어떻게 계산됩니까?$43,252,003,274,489,856,000$

3x3x3 Rubik 's Cube에는 6 개의면이 있으며 각각 9 개의 스티커가 있습니다. 그러나 스티커 대신 (외부) 조각을 보면 가운데 조각이 6 개 있습니다. 8 개의 모서리 조각; 그리고 12 개의 가장자리 조각. 중심을 이동할 수 없으므로 계산에서 중심을 무시할 수 있습니다. 모서리와 가장자리에 관해서 :

• 개가 있습니다( ) 8 코너를 정렬하는 방법. 각 구석에는 3 가지 가능한 방향이 있지만, 8 가지 중 7 가지만 독립적으로 방향을 지정할 수 있습니다. 8 / 8 / 최종 코너의 방향은 ( ) 가능성을 감안할 때 앞의 7 개에 달려 있습니다.$8!$$40,320$$3^7$$2,187$
• 있다 ( 열두 가장자리를 준비하는) 방법. 에서 절반모서리가있을 때 모서리가 항상 균등 한 순열을 유지 해야하기 때문 입니다. ( )의 가능성이 주어지면, 앞의 11에 따라 12 번째 / 최종 가장자리의 플립으로 11 개의 모서리를 독립적으로 뒤집을 수 있습니다 .$\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 큐브의 경우 여전히 간단합니다. 큐브조차도 공식이 약간 다릅니다. 이것은 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 준 진동입니다 .

그리고 더 큰 NxNxN 큐브 (즉, 현재 세계 기록 33x33x33)의 경우 수식이 약간 확장됩니다. 그러나이 소개를 너무 오래 만들지 않기 위해 대신 4x4x4 큐브 및 다른 크기의 NxNxN 큐브의 순열을 결과 수식으로 설명하는 링크를 여기에 넣습니다.

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

x x 큐브에 대해 을 기반으로 한 일반 공식이 있습니까? 확실히있다. 다음은 완전히 다른 3 가지 알고리즘으로, 기준으로 동일한 결과를 제공합니다 .$N$$N$$N$$N$$N$

1 : 크리스 하드윅의 공식 :

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

여기서 은 입니다.$96577$$(13×17×19×23)$

WolframAlpha에서 사용해보십시오.

^{출처 : Cubers-reddit-위치 수, 하나님의 수 등의 수학적 계산 공식}

도전:

범위 의 입력 정수 이 주어지면 올바른 결과를 출력하는 이 세 가지 공식 중 하나 (또는 ​​자신의 파생)를 선택하여 구현 하십시오.$N$$[2,100]$

도전 규칙 :

• 이 세 가지 이외의 다른 수식을 자유롭게 사용할 수 있지만이 세 가지가 정확하다는 것을 명심하십시오. 다른 수식을 사용하는 경우 수식의 위치에 대한 링크를 추가하십시오 (또는 수식이있는 경우 자세한 설명을 추가하십시오). 그리고 출력이 올바른 경우 범위의 모든 정수를 확인합니다. 이 순서 에 대한 oeis 에서 영감을 얻을 수있을 것입니다 : A075152 .
• 만약 당신의 언어가 자동적으로 과학적인 결과물을 출력한다면 (즉 , 4x4x4 공식 다음의 숫자 대신에 ) 이것이 허용됩니다. 그러나 코드에 수식을 실행하는 동안 부동 소수점 정밀도로 인한 반올림 오류가 허용되지 않으므로 결과에 과학적 반올림을 정확한 출력으로 변환하는 추가 코드를 추가하여 결과를 확인할 수 있습니다. 실제 결과는 정확한.$1.401...×10^{45}$
• 프로그램 / 함수는 범위의 입력에 대해 정확해야합니다 ( 이미 엄청난 수의 숫자 를 생성하기 때문에이를 출력 할 수 있으면 더 큰 도 잘 작동 할 것입니다) 하나 올바르게).$[2,100]$$N=100$$N$
• 카운터로 모든 가능한 순열을 반복 할 수는 없습니다. 카운터를 사용하면 합리적인 시간 내에 아무것도 출력하지 않기 때문입니다. 수식 (제공된 세 가지 중 하나, 그 중 하나의 파생어 또는 완전히 새로운 수식) 또는 적절한 시간 내에 정확한 결과를 제공하는 다른 방법 (하드 코딩없이) 만 구현 )가 허용됩니다. 나는 이것을 시행하기 위해 제한된 시간 을 추가하는 것에 대해 생각 했지만 code-golf 와 함께 제한된 시간 에 개인적으로 맞지 않으므로 그렇게하지 않을 것입니다. 그래도 프로그램이 답변을 제공하는지 확인하고 어떤 이유로 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 Language (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

온라인으로 사용해보십시오!

OEIS 페이지에 있는 Herbert Kociemba 알고리즘 사용

재귀 공식은 다음과 같습니다.
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가 저장 한 6 바이트

@Expired Data로 저장 한 바이트 1 개

x86 기계 코드, 119 바이트

16 진 덤프 :

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으로 시작 하여 루프 에서 코드를 정렬 할 수있게합니다 .

큰 숫자는 십진수 형식으로 표시됩니다. 각 바이트는 MSB에서 시작하여 0 ... 9 범위의 값입니다.

곱셈은 ​​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 (여기에서 많은 자릿수) ... (여기에서 많은 0) 0000000000000000

05AB1E , 38 바이트

초기 시도. Chris Hardwick의 Formula를
사용합니다 . 더 골프를 치고 시간이 있으면 설명해 드리겠습니다.

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

온라인으로 사용해보십시오!

줄리아 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의 공식을 사용합니다. 입력을 큰 정수로 사용합니다.

-7 바이트의 H.PWiz 덕분에

파이썬 2 , 72 바이트

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

온라인으로 사용해보십시오!

Neiln*(n-2)/4 에서 복사 하여 4 바이트를 절약했습니다 .

Wolfram Language (Mathematica) , 67 바이트

Chris Hardwick의 공식 사용.

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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 81 바이트

허버트 코 cie 바의 재귀 공식. BigInt를 입력으로 사용합니다.

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

온라인으로 사용해보십시오!

---

자바 스크립트 (Node.js) ,  102 98  96 바이트

크리스 하드윅의 공식. BigInt를 입력으로 사용합니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (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

그런 다음 거듭 제곱은 지수별로 그룹화 될 수 있으므로 예를 들어 p의 지수입니다 11*7*5**2*3**3*2**14.

라켓 , 151141 바이트

페더레이션 덕분에 -7 바이트!

(λ(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의 공식을 사용하는 가장 긴 대답 :)

파이썬 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 재귀 방법을 사용합니다.

Herman L 덕분에 -2 바이트

젤리 ,  39  38 바이트

^{골프를 놓친 것 같지만 ...}

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

Chris Hardwick의 공식을 구현하는 모나드 링크.

온라인으로 사용해보십시오! 또는 테스트 슈트 (n=[1..33])를참조하십시오.

CJam (47 바이트)

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

온라인 데모

이것은 OEIS에서 Herbert Kociemba의 재귀를 구현합니다 : 사용하여 CJam의 메모 재귀 연산자 . 나는 CJJ를 읽는 사람들에게 쉽게 대응할 수 있도록 MathJax 블록의 용어를 코드와 같은 순서로 주문했다. 더 이상의 해부는 더 이상 빛을 발하지 않을 것이다.

$$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Ḟɠ’:Ñ

온라인으로 사용해보십시오!

아이콘 , 125110 바이트

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

온라인으로 사용해보십시오!

펄 6 , 85 바이트

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

온라인으로 사용해보십시오!

하스켈 , 86 85 74 바이트

^{H.PWiz 덕분에 -1 바이트 절약
Max Yekhlakov 덕분에 -11 바이트 절약}

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)

온라인으로 사용해보십시오!

파이썬 2 , 92 바이트

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

온라인으로 사용해보십시오!

껍질 , 51 48 44 바이트

H.PWiz 덕분에 -4 바이트

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

온라인으로 사용해보십시오!

크리스 하드윅의 공식입니다. 또한 이것은 나의 첫 번째 껍질 프로그램이므로 모든 팁을 주시면 감사하겠습니다.

C ++, 187 1180 180176195 (버그가 있음) 193 175 바이트 (천장 고양이의 도움으로)

이것은 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