Introdução:

Um cubo de Rubik de 3x3x3 possui permutações possíveis, o que equivale a aproximadamente 43 quintilhões . Você já deve ter ouvido falar sobre esse número antes, mas como ele é realmente calculado?$43,252,003,274,489,856,000$

Um cubo de Rubik 3x3x3 tem seis lados, cada um com nove adesivos. Observando as peças (externas) em vez de adesivos, porém, temos seis peças centrais; peças de oito cantos; e doze peças de borda. Como os centros não podem ser movidos, podemos ignorá-los nos cálculos. Quanto aos cantos e arestas:

• Existem( ) maneiras de organizar os oito cantos. Cada canto tem três orientações possíveis, embora apenas sete (dos oito) possam ser orientados independentemente; a orientação do oitavo / canto final depende dos sete anteriores, dadas ( ) possibilidades.$8!$$40,320$$3^7$$2,187$
• Existem ( ) maneiras de organizar as doze arestas. A metade deé porque as arestas devem estar sempre em uma permutação uniforme exatamente quando os cantos estão. Onze arestas podem ser invertidas independentemente, com o giro da décima segunda / aresta final, dependendo das onze anteriores, com ( ) possibilidades.$\frac{12!}{2}$$239,500,800$$12!$$2^{11}$$2,048$

Juntando isso, temos a seguinte fórmula:

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

^{Fonte: Wikipedia - Permutações do cubo de Rubik}

Embora isso possa parecer bastante complexo, ainda é bastante simples para um cubo 3x3x3. Para cubos pares, a fórmula é um pouco diferente; esta é a fórmula para um cubo 4x4x4, por exemplo:

$$\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 é aproximadamente 7,40 quattuordecilhões em pequena escala .

E para cubos NxNxN maiores (ou seja, o atual recorde mundial de 33x33x33), a fórmula será estendida um pouco. Para não tornar essa introdução muito longa, coloquei esses links aqui, onde as permutações do cubo 4x4x4 e alguns cubos NxNxN de outros tamanhos são explicados com uma fórmula resultante:

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

Você já deve estar se perguntando: existe uma fórmula geral baseada em para qualquer cubo x x ? Certamente existe. Aqui estão três algoritmos completamente diferentes, todos dando exatamente os mesmos resultados com base em :$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}}$$

Experimente no 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})}}$$

Experimente no WolframAlpha.

3: Primos de Christopher Mowla Fórmula:

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

onde é .$96577$$(13×17×19×23)$

Experimente no WolframAlpha.

^{Fonte: Cubers-reddit - Fórmulas matemáticas de contagem de número de posições, número de Deus, etc.}

Desafio:

Escolha e implemente uma dessas três fórmulas (ou sua própria derivada), que fornece um número inteiro de entrada no intervalo , produz o resultado correto.$N$$[2,100]$

Regras do desafio:

• Você é livre para usar outra fórmula além dessas três, mas lembre-se de que essas três estão corretas. Se você usar outra fórmula, adicione um link de onde a obteve (ou, se você a criar, adicione uma explicação detalhada). E vou verificar todos os números inteiros no intervalo, se a saída estiver correta. Talvez a inspiração possa ser encontrada nos oeis para esta sequência: A075152 .
• Se o seu idioma gerar automaticamente uma saída científica (ou seja, vez do número após a fórmula 4x4x4), isso é permitido. Mas adicione código adicional à sua resposta para converter esse arredondamento científico em uma saída exata para que os resultados possam ser verificados, pois não são permitidos erros de arredondamento devido à precisão do ponto flutuante durante a execução da fórmula em seu código - o resultado real deve ser exato.$1.401...×10^{45}$
• Seu programa / função deve estar correto para pelo menos as entradas no intervalo (embora, como já resulte em um número imenso, qualquer maior provavelmente funcionará tão bem se você conseguir produzir isso um corretamente).$[2,100]$$N=100$$N$
• Você não tem permissão para repetir todas as permutações possíveis com um contador, pois isso nunca produziria nada em um período de tempo razoável. Somente a implementação de uma fórmula (uma das três fornecidas, um derivado de uma delas ou uma fórmula completamente nova) ou outro método que fornecerá os resultados corretos em um período de tempo razoável (sem codificação embutida, é claro) ) é permitido. Pensei em adicionar um tempo restrito para impor isso, mas pessoalmente sou contra o tempo restrito em combinação com o código-golfe , então não o farei. Ainda assim, verifique se o seu programa fornece as respostas e, se for muito lento para o TIO, por algum motivo, adicione algumas capturas de tela com a saída da máquina local como verificação.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta com as regras de E / S padrão , para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código (ou seja, TIO ).
• Além disso, é altamente recomendável adicionar uma explicação para sua resposta.

Casos de teste:

Aqui estão os casos de teste para no intervalo (fique à vontade para usar os links WolframAlpha acima para casos de teste maiores):$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

NOTA: Como esse é um desafio do código-golfe , basicamente se resume a: implementar uma dessas três fórmulas (ou um derivado / seu próprio método que ainda produz os resultados corretos) o mais curto possível.

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

Experimente online!

usa o algoritmo de Herbert Kociemba encontrado na página OEIS

aqui está a 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 salvos por @Peter Taylor

mais um byte salvo 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

A função recebe o número nem ecx, e um ponteiro para uma cadeia de enchimento em edx(ou seja, fastcallconvenção).

Antes de mostrar o código fonte, algumas explicações sobre como ele funciona. Ele usa a fórmula recursiva, que escrevi da seguinte maneira:

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

Então, todo o código deve fazer é multiplicar por números pequenos. Os números estão no intervalo de 6 a 36, ​​que é pequeno o suficiente para ser representado em um bitmap de 32 bits. Na verdade, não armazeno o bit que representa a multiplicação por 6 - isso permite organizar o código em um do-whileloop, começando com a multiplicação incondicional por 6.

Os grandes números são representados usando a forma decimal - cada byte é um valor no intervalo de 0 a 9, começando no MSB.

A multiplicação é realizada de LSB para MSB; assume que o número de dígitos aumentará 2 para cada multiplicação. Depois de fazer a multiplicação por um fator pequeno como 6, o número de dígitos pode aumentar em apenas 1. Portanto, se MSB = 0, move todo o resultado intermediário para a esquerda. Na verdade, pode acontecer que o número de dígitos não aumente e, em seguida, o MSB ainda será 0, mas esse problema será corrigido conforme o código avança para fatores maiores.

Como o código de multiplicação é grande, não quero colocá-lo duas vezes. Também não quero movê-lo para uma função, porque o código da máquina para chamar uma função é grande. Então, reorganizei os loops externos de forma que o código multiplicador seja necessário apenas uma 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';
    }
}

Desmontagem:

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;

O tempo de execução para n = 100 é de cerca de 4 segundos e o resultado é um número com 38416 dígitos:

23491019577617 (muitos dígitos aqui) ... (muitos zeros aqui) 0000000000000000

05AB1E , 38 bytes

Tentativa inicial.
Usa a fórmula de Chris Hardwick .
Vou tentar jogar mais e explicar quando tiver tempo.

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

Experimente online!

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)

Experimente online!

Usa a fórmula de Chris Hardwick. Recebe entrada como Big inteiro.

Graças 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)

Experimente online!

Salva 4 bytes copiando n*(n-2)/4do Neil .

Wolfram Language (Mathematica) , 67 bytes

Usando a fórmula de Chris Hardwick.

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

Experimente online!

JavaScript (Node.js) , 81 bytes

A fórmula recursiva de Herbert Kociemba. Toma um BigInt como entrada.

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

Experimente online!

---

JavaScript (Node.js) ,  102 98  96 bytes

A fórmula de Chris Hardwick. Toma um BigInt como entrada.

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

Experimente online!

JavaScript (Node.js) , 77 75 73 bytes

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

Experimente online! Baseado na fórmula de Christopher Mowla. Toma um BigInt como entrada. Arnês de teste roubado descaradamente do @Arnauld. 0xb88d4641131f0nestá 3246670537110000nem decimal. Explicação: Comecei com o último expoente primo e simplifiquei para n*(n-2n)/4n(esta é a divisão inteira, portanto, não preciso do ajuste para números ímpares). Em seguida, examinei os outros números primos para ver se seus expoentes estavam relacionados a esse valor (ao qual chamarei de o) e descobri que eles estavam de certa forma, se permitisse o uso da paridade de n(ao qual me referirei como p) As fórmulas para os expoentes são as seguintes:

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

Os poderes podem então ser agrupados por expoente, por exemplo, po expoente de 11*7*5**2*3**3*2**14.

Raquete , 151 141 bytes

-7 bytes graças 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))))

Experimente online!

A resposta mais longa usando a 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)

Experimente online!

Usa o método recursivo de Herbert Kociemba.

-2 bytes graças a Herman L

Geléia ,  39  38 bytes

^{Sinto que perdi alguns tacos, mas ...}

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

Um link monádico implementando a fórmula de Chris Hardwick.

Experimente online! Ou veja a suíte de testes (n=[1..33]).

CJam (47 bytes)

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

Demonstração online

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

Gelatina , 43 bytes

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

Experimente online!

Ícone , 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

Experimente online!

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

Experimente online!

Perl 6 , 85 bytes

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

Experimente online!

Haskell , 86 85 74 bytes

^{-1 bytes salvos graças a H.PWiz
-11 bytes salvos graças 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)

Experimente online!

Python 2 , 92 bytes

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

Experimente online!

Casco , 51 48 44 bytes

-4 bytes graças a H.PWiz

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

Experimente online!

Esta é a fórmula de Chris Hardwick. Além disso, este é o meu primeiro programa de cascas, então qualquer dica seria bem-vinda.

C ++, 187 185 180 176 195 (houve um erro) 193 175 bytes (com ajuda do teto cat)

Ele usa o wrapper GMP C ++ (biblioteca de precisão múltipla GNU) e a fórmula usada por @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Use g++ -g rubix.cpp -lgmp -lgmpxxpara compilar e 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);}

ungolfed, com código de teste

#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 , (não competitivo)

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

Expressão que recebe a entrada como um número inteiro Ans. Implementação da fórmula de Chris Hardwick. Não-concorrente porque o hardware em que ele roda armazena apenas até 16 casas decimais, portanto a resposta nunca será 100% precisa.

Explicação:

{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