Введение:

Кубик Рубика 3x3x3 имеет возможных перестановок, что составляет приблизительно 43 квинтиллиона . Возможно, вы слышали об этом числе раньше, но как оно на самом деле рассчитывается?$43,252,003,274,489,856,000$

Кубик Рубика 3х3х3 имеет шесть граней, каждая из которых имеет девять стикеров. Глядя на (внешние) части вместо наклеек, у нас есть шесть центральных частей; восемь угловых частей; и двенадцать краев. Поскольку центры не могут быть перемещены, мы можем игнорировать их в расчетах. Что касается углов и краев:

• Есть( ) способов расставить восемь углов. Каждый угол имеет три возможных ориентации, хотя только семь (из восьми) могут быть ориентированы независимо; ориентация восьмого / последнего угла зависит от предыдущих семи, учитывая ( 2 , 187 ) возможностей.$8!$$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 другого размера объясняются полученной формулой:

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

Вы можете задаться вопросом: есть ли общая формула, основанная на $N$ для любого куба $N$ x $N$ x $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]$ , выводит правильный результат.

Правила соревнований:

• Вы можете использовать другую формулу помимо этих трех, но имейте в виду, что эти три оказались правильными. Если вы используете другую формулу, пожалуйста, добавьте ссылку, откуда вы ее взяли (или, если вы придумали ее самостоятельно, добавьте подробное объяснение). И я проверю все целые числа в диапазоне, если вывод правильный. Возможно, в oeis можно найти вдохновение для этой последовательности: A075152 .
• Если ваш язык автоматически выводит научный вывод (т.е. $1.401...×10^{45}$ вместо числа после формулы 4x4x4), это разрешается. Но, пожалуйста, добавьте дополнительный код в ваш ответ, чтобы преобразовать это научное округление в точный вывод, чтобы результаты могли быть проверены, поскольку ошибки округления из-за точности с плавающей запятой при выполнении формулы в вашем коде не допускаются - фактический результат должен быть точный.
• Ваша программа / функция должна быть правильной, по крайней мере, для входов в диапазоне $[2,100]$ (хотя, поскольку $N=100$ уже приводит к большому количеству заданий, любой больший $N$ , вероятно, будет работать так же хорошо, если вы сможете выведите это правильно).
• Вы не можете циклически перебирать все возможные перестановки со счетчиком, так как это никогда не выдаст ничего за разумное время. Только реализация формулы (либо одна из трех представленных, производная от одной из них, либо совершенно новая формула), либо другой метод, который даст правильные результаты за разумное время (без жесткого кодирования, конечно ) разрешено. Я думал о добавлении ограниченного времени для обеспечения этого, но я лично против ограниченного времени в сочетании с code-golf , поэтому я не буду. Тем не менее, пожалуйста, убедитесь, что ваша программа дает ответы, и, если по какой-то причине она слишком медленная для 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

ПРИМЕЧАНИЕ. Так как это задача для игры в гольф , она сводится к следующему: реализовать одну из этих трех формул (или производный / ваш собственный метод, который все еще дает правильные результаты) как можно короче.

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

вот рекурсивная формула:
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с Нила .

Wolfram Language (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 байт благодаря 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))))

Попробуйте онлайн!

Самый длинный ответ с использованием формулы Криса Хардвика :)

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 байта благодаря Herman L

Желе ,  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

Онлайн демо

Это реализует рекурсию Герберта Кочембы из OEIS:

$$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}$$ используя запомнившийся оператор рекурсии CJam j. Я упорядочил термины в блоке MathJax в том же порядке, что и в коде, чтобы облегчить проверку соответствия для тех, кто читает CJam: любое дальнейшее изучение не будет проливать больше света.

Желе , 43 байта

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

Попробуйте онлайн!

Icon , 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