Introduzione:

Un cubo di Rubik 3x3x3 ha $43,252,003,274,489,856,000$ possibili permutazioni, che è di circa 43 quintilioni . Potresti aver sentito parlare di questo numero prima, ma come viene effettivamente calcolato?

Un cubo di Rubik 3x3x3 ha sei lati, ciascuno con nove adesivi. Osservando i pezzi (esterni) invece degli adesivi, abbiamo sei pezzi centrali; pezzi di otto angoli; e dodici pezzi di bordo. Poiché i centri non possono essere spostati, possiamo ignorarli nei calcoli. Per quanto riguarda gli angoli e i bordi:

• Ce ne sono $8!$( $40,320$ ) modi per disporre gli otto angoli. Ogni angolo ha tre possibili orientamenti, sebbene solo sette (degli otto) possano essere orientati indipendentemente; l'orientamento dell'ottava / ultima curva dipende dalle sette precedenti, date $3^7$ ( $2,187$ ) possibilità.
• Ce ne sono $\frac{12!}{2}$ ($239,500,800$) modi per disporre i dodici bordi. La metà da$12!$è perché i bordi devono essere sempre in unapermutazione uniformeesattamente quando gli angoli sono. Undici bordi possono essere capovolti in modo indipendente, con il capovolgimento del dodicesimo / bordo finale a seconda degli undici precedenti, date$2^{11}$($2,048$).

Mettendo insieme questo, abbiamo la seguente formula:

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

^{Fonte: Wikipedia - permutazioni del cubo di Rubik}

Anche se questo può già sembrare piuttosto complesso, è ancora piuttosto semplice per un cubo 3x3x3. Per i cubi pari la formula è leggermente diversa; questa è la formula per un cubo 4x4x4 ad esempio:

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

Che è circa 7,40 quattuordecilioni sulla scala corta .

E per i cubi NxNxN più grandi (ovvero l'attuale record mondiale 33x33x33) la formula verrà estesa un po '. Per non rendere questa introduzione troppo lunga, ho inserito qui questi collegamenti, in cui le spiegazioni del cubo 4x4x4 e di altri cubi NxNxN di dimensioni sono spiegate con una formula risultante:

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

Ormai ti starai chiedendo: esiste una formula generale basata su $N$ per qualsiasi cubo $N$ x $N$ x $N$ ? Certamente c'è. Ecco tre algoritmi completamente diversi, tutti con gli stessi esatti risultati basati su $N$ :

1: Formula di 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}}$$

Provalo su WolframAlpha.

2: formula di 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})}}$$

Try it on WolframAlpha.

3: Christopher Mowla's primes Formula:

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

where $96577$ is $(13×17×19×23)$.

Try it on WolframAlpha.

^{Source: Cubers-reddit - Mathematical Counting Formulas of Number of Positions, God's Number, etc.}

Challenge:

Choose and implement one of these three formulas (or your own derivative), which given an input-integer $N$ in the range $[2,100]$, outputs the correct result.

Challenge rules:

• You are free to use another formula besides these three, but keep in mind that these three are proven to be correct. If you use another formula, please add a link of where you got it from (or if you come up with it yourself add an in-depth explanation). And I will check for all integers in the range if the output is correct. Perhaps inspiration could be found in the oeis for this sequence: A075152.
• If your language automatically outputs a scientific output (i.e. $1.401...×10^{45}$ instead of the number after the 4x4x4 formula) this is allowed. But please add additional code to your answer to convert this scientific rounding to an exact output so the results can be verified, since rounding errors due to floating point precision during the execution of the formula in your code is not allowed - the actual result should be exact.
• Your program/function should be correct for at least the inputs in the range $[2,100]$ (although, since $N=100$ already results in a huge-ass number, any larger $N$ will probably work as well if you're able to output this one correctly).
• You are not allowed to loop over all possible permutations with a counter, since that would never output anything in a reasonable amount of time. Only the implementation of a formula (either one of the three provided, a derivative of one of those, or a completely new formula), or another method that will give the correct results in a reasonable amount of time (without hard-coding of course) is allowed. I thought about adding a restricted-time to enforce this, but I'm personally against restricted-time in combination with code-golf, so I won't. Still, please make sure your program gives the answers, and if it's too slow for TIO for some reason, add some screenshots with the output from your local machine as verification.

General rules:

• This is code-golf, so shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code (i.e. TIO).
• Also, adding an explanation for your answer is highly recommended.

Test cases:

Here the test cases for $N$ in the range $[2,10]$ (feel free to use the WolframAlpha links above for larger test cases):

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

NOTE: Since this is a code-golf challenge, it basically boils down to: implement one of these three formulas (or a derivative / your own method that still produces the correct results) as short as possible.

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

Try it online!

uses Herbert Kociemba's algorithm found in OEIS page

here is the recursive formula:
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 saved by @Peter Taylor

one more byte saved by @Expired Data

x86 machine code, 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

The function receives the number n in ecx, and a pointer to a string to fill in edx (i.e. fastcall convention).

Before I show the source code, some explanations on how it does the thing. It uses the recursive formula, which I wrote in the following way:

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

So all the code should do is multiplication by small numbers. The numbers are in the range 6...36, which is small enough to be represented in a 32-bit bitmap. I actually don't store the bit which represents multiplication by 6 - this lets me arrange the code in a do-while loop, starting with unconditional multiplication by 6.

The big numbers are represented using decimal form - each byte is a value in the range 0...9, starting from the MSB.

La moltiplicazione viene eseguita da LSB a MSB; presuppone che il numero di cifre aumenti di 2 per ogni moltiplicazione. Dopo aver moltiplicato per un piccolo fattore come 6, il numero di cifre può aumentare solo di 1. Quindi, se MSB = 0, sposta l'intero risultato intermedio a sinistra. In realtà può accadere che il numero di cifre non cresca affatto, e quindi MSB sarà ancora 0, ma questo problema si risolverà da solo man mano che il codice procede a fattori maggiori.

Poiché il codice di moltiplicazione è grande, non voglio metterlo due volte. Non voglio nemmeno spostarlo in una funzione, perché il codice macchina per chiamare una funzione è grande. Quindi ho riordinato i loop esterni in modo tale che il codice moltiplicativo sia necessario solo una volta.

Codice 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';
    }
}

Smontaggio:

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;

Il tempo di esecuzione per n = 100 è di circa 4 secondi e il risultato è un numero con 38416 cifre:

23491019577617 (molte cifre qui) ... (molti zeri qui) 0000000000000000

05AB1E , 38 byte

Tentativo iniziale.
Usa la formula di Chris Hardwick .
Proverò a giocare a golf ulteriormente e spiegherà quando ho tempo.

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

Provalo online!

Julia 1.0 , 83 76 byte

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

Provalo online!

Usa la formula di Chris Hardwick. Accetta l'input come intero grande.

Grazie a H.PWiz per -7 byte

Python 2 , 72 byte

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

Provalo online!

Salvato 4 byte copiando n*(n-2)/4da Neil .

Wolfram Language (Mathematica) , 67 byte

Usando la formula di Chris Hardwick.

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

Provalo online!

JavaScript (Node.js) , 81 byte

La formula ricorsiva di Herbert Kociemba. Prende un BigInt come input.

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

Provalo online!

---

JavaScript (Node.js) ,  102 98  96 byte

La formula di Chris Hardwick. Prende un BigInt come input.

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

Provalo online!

JavaScript (Node.js) , 77 75 73 byte

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

Provalo online! Basato sulla formula di Christopher Mowla. Prende un BigInt come input. Cablaggio di prova spudoratamente rubato da @Arnauld. 0xb88d4641131f0nè 3246670537110000nin decimale. Spiegazione: Ho iniziato con l'ultimo esponente principale e l'ho semplificato n*(n-2n)/4n(questa è una divisione intera, quindi non ho bisogno della correzione per i numeri dispari). Ho quindi esaminato gli altri numeri primi per vedere se i loro esponenti fossero collegati a questo valore (di cui mi riferirò come o), e ho scoperto che erano secondo una moda, se avessi permesso l'uso della parità di n(di cui mi riferirò come p). Le formule per gli esponenti sono le seguenti:

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

I poteri possono quindi essere raggruppati per esponente, ad esempio pè l'esponente di 11*7*5**2*3**3*2**14.

Racchetta , 151 141 byte

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

Provalo online!

La risposta più lunga usando la formula di Chris Hardwick :)

Python 2 , 122 byte

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)

Provalo online!

Utilizza il metodo ricorsivo Herbert Kociemba.

-2 byte grazie a Herman L

Gelatina ,  39  38 byte

^{Mi sento come se avessi perso alcuni golf, ma ...}

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

Un collegamento monadico che implementa la Formula di Chris Hardwick.

Provalo online! Oppure vedi la suite di test (n=[1..33]).

CJam (47 byte)

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

Demo online

Questo implementa la ricorsione di Herbert Kociemba dall'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}$$ utilizzando l'operatore di ricorsione memorizzato da CJam j. Ho ordinato i termini nel blocco MathJax nello stesso ordine del codice per facilitare la verifica della corrispondenza per coloro che leggono CJam: qualsiasi ulteriore dissezione non farà luce.

Gelatina , 43 byte

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

Provalo online!

Icona , 125 110 byte

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

Provalo online!

C (gcc) -lgmp, 279 byte

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

Provalo online!

Perl 6 , 85 byte

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

Provalo online!

Haskell , 86 85 74 byte

^{-1 byte salvato grazie a H.PWiz
-11 byte salvati grazie 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)

Provalo online!

Python 2 , 92 byte

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

Provalo online!

Buccia , 51 48 44 byte

-4 byte grazie a H.PWiz

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

Provalo online!

Questa è la formula di Chris Hardwick. Inoltre, questo è il mio primo programma husk, quindi ogni consiglio sarebbe apprezzato.

C ++, 187 185 180 176 195 195 (c'era un bug) 193 175 byte (con l'aiuto del gatto del soffitto)

Questo utilizza il wrapper C ++ GMP (libreria multi-precisione GNU) e la formula utilizzata da @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Utilizzare g++ -g rubix.cpp -lgmp -lgmpxxper compilare e collegare

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

non golfato, con codice di prova

#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 byte , (non 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

Espressione che accetta input come numero intero attivo Ans. Implementazione della formula di Chris Hardwick. Non competitivo perché l'hardware su cui viene eseguito memorizzerà solo fino a 16 cifre decimali, quindi la risposta non sarà mai precisa al 100%.

Spiegazione:

{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