Introducción:

Un cubo de Rubik 3x3x3 tiene permutaciones posibles, que es aproximadamente 43 quintillones . Es posible que haya escuchado sobre este número antes, pero ¿cómo se calcula realmente?$43,252,003,274,489,856,000$

Un cubo de Rubik 3x3x3 tiene seis lados, cada uno con nueve pegatinas. Sin embargo, al mirar las piezas (externas) en lugar de las pegatinas, tenemos seis piezas centrales; piezas de ocho esquinas; y doce piezas de borde. Como los centros no se pueden mover, podemos ignorarlos en los cálculos. En cuanto a las esquinas y bordes:

• Hay( ) formas de organizar las ocho esquinas. Cada esquina tiene tres orientaciones posibles, aunque solo siete (de las ocho) pueden orientarse independientemente; la orientación de la esquina octava / final depende de las siete anteriores, dadas ( ) posibilidades.$8!$$40,320$$3^7$$2,187$
• Hay ( ) formas de organizar los doce bordes. La mitad de lases porque los bordes siempre deben estar en una permutación pareja exactamente cuando las esquinas están Once aristas se pueden voltear de forma independiente, con la inversión de la doceava / última arista dependiendo de las once anteriores, dadas ( ) posibilidades.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Al poner esto juntos, tenemos la siguiente fórmula:

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

^{Fuente: Wikipedia - Permutaciones del cubo de Rubik}

Aunque esto puede parecer bastante complejo, sigue siendo bastante sencillo para un Cubo de 3x3x3. Para cubos pares, la fórmula es ligeramente diferente; Esta es la fórmula para un cubo 4x4x4, por ejemplo:

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

Que es aproximadamente 7.40 quattuordecillion en la escala corta .

Y para cubos NxNxN más grandes (es decir, el récord mundial actual 33x33x33), la fórmula se ampliará bastante. Sin embargo, para no hacer esta introducción demasiado larga, pongo estos enlaces aquí, donde las permutaciones del Cubo 4x4x4 y algunos Cubos NxNxN de otro tamaño se explican con una fórmula resultante:

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

Quizás ya se esté preguntando: ¿existe una fórmula general basada en para cualquier cubo x x ? Ciertamente lo hay. Aquí hay tres algoritmos completamente diferentes, todos dando exactamente los mismos resultados basados ​​en N :$N$$N$$N$$N$$N$

1: Fórmula de 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}}$$

Pruébalo en WolframAlpha.

2: Fórmula trigonométrica de 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})}}$$

Pruébalo en WolframAlpha.

3: Fórmula de los primos de 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)}$$

donde es .$96577$$(13×17×19×23)$

Pruébalo en WolframAlpha.

^{Fuente: Cubers-reddit - Fórmulas de conteo matemático de número de posiciones, número de Dios, etc.}

Reto:

Elija e implemente una de estas tres fórmulas (o su propia derivada), que dado un entero de entrada en el rango , genera el resultado correcto.$N$$[2,100]$

Reglas de desafío:

• Puede usar otra fórmula además de estas tres, pero tenga en cuenta que se ha demostrado que estas tres son correctas. Si usa otra fórmula, agregue un enlace de donde la obtuvo (o si se le ocurre, agregue una explicación detallada). Y comprobaré todos los enteros en el rango si la salida es correcta. Quizás se pueda encontrar inspiración en los oeis para esta secuencia: A075152 .
• Si su idioma genera automáticamente un resultado científico (es decir, lugar del número después de la fórmula 4x4x4), esto está permitido. Pero agregue un código adicional a su respuesta para convertir este redondeo científico en un resultado exacto para que se puedan verificar los resultados, ya que los errores de redondeo debido a la precisión de coma flotante durante la ejecución de la fórmula en su código no están permitidos; exacto.$1.401...×10^{45}$
• Su programa / función debe ser correcto para al menos las entradas en el rango (aunque, dado que ya da como resultado un número enorme, cualquier mayor probablemente funcionará también si puede generar esto uno correctamente).$[2,100]$$N=100$$N$
• No está permitido recorrer todas las permutaciones posibles con un contador, ya que eso nunca generaría nada en un período de tiempo razonable. Solo la implementación de una fórmula (ya sea una de las tres proporcionadas, una derivada de una de ellas o una fórmula completamente nueva) u otro método que brinde los resultados correctos en un período de tiempo razonable (sin codificación, por supuesto) ) esta permitido. Pensé en agregar un tiempo restringido para hacer cumplir esto, pero personalmente estoy en contra del tiempo restringido en combinación con el código de golf , por lo que no lo haré. Aún así, asegúrese de que su programa dé las respuestas, y si por algún motivo es demasiado lento para TIO, agregue algunas capturas de pantalla con la salida de su máquina local como verificación.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Aquí los casos de prueba para $N$ en el rango $[2,10]$ (siéntase libre de usar los enlaces WolframAlpha anteriores para casos de prueba más grandes):

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

NOTA: Dado que este es un desafío de código de golf , básicamente se reduce a: implementar una de estas tres fórmulas (o una derivada / su propio método que aún produce los resultados correctos) lo más breve posible.

Wolfram Language (Mathematica) , 59 bytes

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

Pruébalo en línea!

utiliza el algoritmo de Herbert Kociemba que se encuentra en la página OEIS

Aquí está la fórmula recursiva:
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 bytes guardados por @Peter Taylor

un byte más guardado por @Expired Data

código de máquina x86, 119 bytes

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

La función recibe el número nen ecx, y un puntero a una cadena de rellenar edx(es decir fastcallconvención).

Antes de mostrar el código fuente, algunas explicaciones sobre cómo funciona. Utiliza la fórmula recursiva, que escribí de la siguiente manera:

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

Entonces, todo lo que debe hacer el código es la multiplicación por números pequeños. Los números están en el rango 6 ... 36, que es lo suficientemente pequeño como para representarse en un mapa de bits de 32 bits. En realidad, no almaceno el bit que representa la multiplicación por 6; esto me permite organizar el código en un do-whilebucle, comenzando con la multiplicación incondicional por 6.

Los números grandes se representan usando la forma decimal: cada byte es un valor en el rango 0 ... 9, comenzando desde el MSB.

La multiplicación se realiza de LSB a MSB; se supone que el número de dígitos crecerá en 2 por cada multiplicación. Después de multiplicar por un factor pequeño como 6, el número de dígitos puede crecer solo 1. Por lo tanto, si MSB = 0, mueve todo el resultado intermedio a la izquierda. En realidad, puede suceder que el número de dígitos no crezca en absoluto, y luego MSB seguirá siendo 0, pero este problema se solucionará a medida que el código proceda a factores mayores.

Debido a que el código de multiplicación es grande, no quiero ponerlo dos veces. Tampoco quiero moverlo a una función, porque el código de máquina para llamar a una función es grande. Así que reorganicé los bucles externos de tal manera que el código de multiplicación se necesita solo una vez.

Código 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';
    }
}

Desmontaje

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;

El tiempo de ejecución para n = 100 es de aproximadamente 4 segundos, y el resultado es un número con 38416 dígitos:

23491019577617 (muchos dígitos aquí) ... (muchos ceros aquí) 0000000000000000

05AB1E , 38 bytes

Intento inicial
Utiliza la fórmula de Chris Hardwick .
Intentaré jugar más al golf y explicar cuando tenga tiempo.

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

Pruébalo en línea!

Julia 1.0 , 83 76 bytes

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

Pruébalo en línea!

Utiliza la fórmula de Chris Hardwick. Toma la entrada como entero grande.

Gracias a H.PWiz por -7 bytes

Python 2 , 72 bytes

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

Pruébalo en línea!

Guardado 4 bytes copiando n*(n-2)/4desde Neil .

Wolfram Language (Mathematica) , 67 bytes

Usando la fórmula de Chris Hardwick.

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

Pruébalo en línea!

JavaScript (Node.js) , 81 bytes

La fórmula recursiva de Herbert Kociemba. Toma un BigInt como entrada.

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

Pruébalo en línea!

---

JavaScript (Node.js) ,  102 98  96 bytes

La fórmula de Chris Hardwick. Toma un BigInt como entrada.

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

Pruébalo en línea!

JavaScript (Node.js) , 77 75 73 bytes

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

Pruébalo en línea! Basado en la fórmula de Christopher Mowla. Toma un BigInt como entrada. Pruebe el arnés descaradamente robado de @Arnauld. 0xb88d4641131f0nestá 3246670537110000nen decimal. Explicación: Comencé con el último exponente primo y lo simplifiqué a n*(n-2n)/4n(esta es una división entera, por lo que no necesito el ajuste para números impares). Luego examiné los otros números primos para ver si sus exponentes estaban relacionados con este valor (al que me referiré como o), y descubrí que eran de una moda, si permitía el uso de la paridad de n(a la que me referiré como p) Las fórmulas para los exponentes son las siguientes:

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

Las potencias se pueden agrupar por exponente, por ejemplo, pes el exponente de 11*7*5**2*3**3*2**14.

Raqueta , 151 141 bytes

-7 bytes gracias a 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))))

Pruébalo en línea!

La respuesta más larga usando la fórmula de Chris Hardwick :)

Python 2 , 122 bytes

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)

Pruébalo en línea!

Utiliza el método recursivo Herbert Kociemba.

-2 bytes gracias a Herman L

Jalea ,  39  38 bytes

^{Siento que me he perdido algunos campos de golf, pero ...}

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

Un enlace monádico que implementa la fórmula de Chris Hardwick.

Pruébalo en línea! O vea el conjunto de pruebas (n=[1..33]).

CJam (47 bytes)

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

Demostración en línea

Esto implementa la recurrencia de Herbert Kociemba de 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}$$ utilizando el operador de recursión memorable de CJam j. He ordenado los términos en el bloque MathJax en el mismo orden que en el código para facilitar la verificación de la correspondencia para aquellos que leen CJam: cualquier disección adicional no arrojará más luz.

Jalea , 43 bytes

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

Pruébalo en línea!

Icono , 125 110 bytes

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

Pruébalo en línea!

C (gcc) -lgmp, 279 bytes

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

Pruébalo en línea!

Perl 6 , 85 bytes

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

Pruébalo en línea!

Haskell , 86 85 74 bytes

^{-1 byte guardado gracias a H.PWiz
-11 bytes guardados gracias a 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)

Pruébalo en línea!

Python 2 , 92 bytes

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

Pruébalo en línea!

De cáscara , 51 48 44 bytes

-4 bytes gracias a H.PWiz

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

Pruébalo en línea!

Esto es Fórmula de Chris Hardwick. Además, este es mi primer programa de cáscara, por lo que cualquier consejo sería muy apreciado.

C ++, 187 185 180 176 195 (hubo un error) 193 175 bytes (con ayuda del techo cat)

Utiliza el contenedor GMP C ++ (biblioteca de precisión múltiple GNU) y la fórmula utilizada por @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Úselo g++ -g rubix.cpp -lgmp -lgmpxxpara compilar y vincular

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

sin golf, con código de prueba

#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 bytes , (sin competencia)

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

Expresión que toma la entrada como un entero en Ans. Implementación de la fórmula de Chris Hardwick. Sin competencia porque el hardware en el que se ejecuta solo almacenará hasta 16 decimales, por lo que la respuesta nunca será 100% precisa.

Explicación:

{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