Вступ:

У кубі Рубіка 3x3x3 є можливих перестановок, що становить приблизно 43 квінтільйона . Ви, можливо, чули про це число раніше, але як воно насправді обчислюється?$43,252,003,274,489,856,000$

Кубик Рубіка розміром 3x3x3 має шість сторін, на кожній - дев'ять наклейок. Дивлячись на (зовнішні) частини замість наклейок, маємо шість центральних частин; вісім куточків штук; і дванадцять крайових штук. Оскільки центри неможливо перемістити, ми можемо ігнорувати їх у розрахунках. Що стосується кутів та країв:

• Є( ) способів розташування восьми кутів. Кожен кут має три можливі орієнтації, хоча лише сім (з восьми) можна орієнтувати незалежно; орієнтація восьмого / заключного кута залежить від попередніх семи, заданих ( ) можливостей.$8!$3 7 2 , 187$40,320$$3^7$$2,187$
• Є ( ) способів розташування дванадцяти ребер. Половина зце тому, що краї завжди повинні бути в рівній перестановці саме тоді, коли кути. Одинадцять ребер можна перевернути незалежно, з переворотом дванадцятого / остаточного краю залежно від попередніх одинадцяти, задавши ( ) можливостей.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Збираючи це разом, ми маємо таку формулу:

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

^{Джерело: Вікіпедія - Перестановки в кубі Рубіка}

Хоча це вже може виглядати досить складно, для куба 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 пояснюються отриманою формулою:

• 2х2х2
• 4x4x4
• 5х5х5
• 6x6x6
• 7x7x7
• 33x33x33

Напевно, вам може бути цікаво: чи існує загальна формула, заснована на для будь-якого x x$N$$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: Тригельна формула Крістофера Моули:

$$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: Формули Крістофера Моули:

$$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]$ , виводить правильний результат.

Правила виклику:

• Ви можете використовувати іншу формулу, окрім цих трьох, але майте на увазі, що ці три довели, що вони є правильними. Якщо ви використовуєте іншу формулу, будь ласка, додайте посилання про те, звідки ви її отримали (або якщо ви її самі придумали, додайте поглиблене пояснення). І я перевірю всі цілі числа в діапазоні, якщо вихід правильний. Можливо, натхнення можна було б знайти в ої для цієї послідовності: A075152 .
• Якщо ваша мова автоматично видає науковий результат (тобто $1.401...×10^{45}$ замість числа після формули 4x4x4), це дозволено. Але, будь ласка, додайте до своєї відповіді додатковий код, щоб перетворити це наукове округлення в точний вихід, щоб результати можна було перевірити, оскільки помилки округлення через точність плаваючої точки під час виконання формули у вашому коді не допускаються - фактичний результат повинен бути точний.
• Ваша програма / функція повинна бути правильною щонайменше для входів у діапазоні $[2,100]$ (хоча, оскільки $N=100$ вже призводить до величезного числа осел, будь-який більший $N$ , ймовірно, спрацює, якщо ви зможете виведіть це правильно).
• Вам не дозволяється перебирати всі можливі перестановки лічильником, оскільки це ніколи не виводить нічого за розумну кількість часу. Тільки реалізація формули (будь-якої із трьох наданих, похідної однієї з них, або абсолютно нової формули), або іншого методу, який дасть правильні результати за розумну кількість часу (без жорсткого кодування курсу) ) дозволено. Я думав над тим, щоб додати обмежений час для виконання цього, але я особисто проти обмеженого часу в поєднанні з кодом-гольф , тому не буду. Проте переконайтеся, що ваша програма дає відповіді, і якщо TIO чомусь занадто повільний, додайте кілька знімків екрана з результатами з вашої локальної машини як перевірку.

Загальні правила:

• Це код-гольф , тому найкоротша відповідь у байтах виграє.
  Не дозволяйте мовам коду-гольфу відштовхувати вас від публікації відповідей з мов, що не кодують гольф. Спробуйте придумати якомога коротшу відповідь на "будь-яку" мову програмування.
• Для вашої відповіді застосовуються стандартні правила з правилами вводу / виводу за замовчуванням , тому вам дозволяється використовувати STDIN / STDOUT, функції / метод із відповідними параметрами та повним програмами типу повернення. Твій дзвінок.
• Лазівки за замовчуванням заборонені.
• Якщо можливо, додайте посилання з тестом для вашого коду (тобто TIO ).
• Також настійно рекомендується додавати пояснення до своєї відповіді.

Тестові приклади:

Ось тестові випадки для $N$ у діапазоні $[2,10]$ (сміливо використовуйте вищевказані посилання WolframAlpha для великих тестових випадків):

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

ПРИМІТКА. Оскільки це завдання з кодовим гольфом , воно, як правило, зводиться до: реалізувати одну з цих трьох формул (або похідний / власний метод, який все ще дає правильні результати) якомога коротше.

Мова Вольфрама (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

ось рекурсивна формула:
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÷

Спробуйте в Інтернеті!

Джулія 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)

Спробуйте в Інтернеті!

Використовує формулу Кріса Хардвіка. Вводиться як велике ціле число.

Завдяки 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з Ніла .

Мова Вольфрама (Mathematica) , 67 байт

Використання формули Кріса Хардвіка.

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

Спробуйте в Інтернеті!

JavaScript (Node.js) , 81 байт

Рекурсивна формула Герберта Кочімба. Приймає BigInt як вхід.

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

Спробуйте в Інтернеті!

---

JavaScript (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))

Спробуйте в Інтернеті!

JavaScript (Node.js) , 77 75 73 байт

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

Спробуйте в Інтернеті! На основі формули Крістофера Моули. Приймає 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.

Ракетка , 151 141 байт

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

Спробуйте в Інтернеті!

Найдовша відповідь, використовуючи формулу Кріса Хардвіка :)

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)

Спробуйте в Інтернеті!

Використовується рекурсивний метод Герберта Кочімба.

-2 байти завдяки Герману Л

Желе ,  39  38 байт

^{Я відчуваю, що я пропустив кілька гольфів, але ...}

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

Монадійне посилання, що реалізує формулу Кріса Хардвіка.

Спробуйте в Інтернеті!Або дивіться тестовий набір ( n=[1..33]).

CJam (47 байт)

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

Демонстрація в Інтернеті

$$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 байт збережено завдяки Максу Єхлакову}

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)

Спробуйте в Інтернеті!

Лушпиння , 51 48 44 байт

-4 байти завдяки H.PWiz

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

Спробуйте в Інтернеті!

Це формула Кріса Хардвіка. Також це моя перша програма лушпиння, тому будь-які поради були б добре оцінені.

C ++, 187 185 180 176 195 (була помилка) 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);}

безгольовий, з тестовим кодом

#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 . Впровадження формули Кріса Хардвіка. Не конкуруючи, оскільки обладнання, на яке він працює, зберігатиме лише до 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