Cantidad de permutaciones en un cubo de Rubik NxNxN

35

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,320372,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.12!2239,500,80012!2112,048

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

8!×37×12!2×211=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:

8!×37×24!2247=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:

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 :NNNNN

1: Fórmula de Chris Hardwick:

(24×210×12!)N(mod2)×(7!×36)×(24!)14×(N22×N)(4!)6×14×(N2)2

Pruébalo en WolframAlpha.

2: Fórmula trigonométrica de Christopher Mowla:

8!×37×(24!(4!)6)14×((N1)×(N3)+cos2(N×π2))×(24!)12×(N2sin2(N×π2))×(12!×210)sin2(N×π2)×124cos2(N×π2)

Pruébalo en WolframAlpha.

3: Fórmula de los primos de Christopher Mowla:

212×(2×N×(N+7)1711×(1)N)×3N×(N+1)+2×512×(2×N×(N2)+1+(1)N)×718×(6×N×(N2)+3+5×(1)N)×1114×(2×N×(N2)1+(1)N)×9657718×(2×N×(N2)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...×1045
  • 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=100N
  • 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 para hacer cumplir esto, pero personalmente estoy en contra en combinación con el , 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 , 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 , 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.

Kevin Cruijssen
fuente
2
Hacer esto en x86-64 será un desafío divertido. Tendré que rodar mi propio bigint (probablemente solo un int de 256 o 512 bits), y hacerlo golf.
moonheart08
44
Tenga en cuenta que la fórmula "trig" de Mowla solo usa y cos 2 para ofuscar s. pecado2cos2floor
attinat
44
@attinat, creo que es una perspectiva más útil decir que tanto el trigonoma como los pisos están ofuscando Nmod2
Peter Taylor
2
@ChristopherMowla No tome sus comentarios personales. Estoy sorprendido de que haya podido encontrar estas fórmulas e hizo predicciones tan precisas en primer lugar, y sus fórmulas fueron una de las inspiraciones para este desafío. Sin embargo, este es el código de golf, por lo que la legibilidad, el rendimiento, las advertencias, las mejores prácticas, el significado histórico y, a veces, el sentido común se tiran por la borda si puede guardar un solo byte en una respuesta. ;) attinat y PeterTaylor simplemente sugirieron tal golf basado en sus fórmulas, ya que N mod 2 es bastante más corto de usar en lenguajes de programación que trigonometría.
Kevin Cruijssen

Respuestas:

12

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

J42161217
fuente
65 bytes
Datos
@ExpiredData muy agradable! Estaba tratando de hacer lo mismo pero falló porque el orden era diferente
J42161217
La pregunta no requiere soporte f@1, por lo que puede guardar 6 bytes. Obviamente, también querrás ajustar el marco de prueba para usar Range[2,10].
Peter Taylor
@PeterTaylor gran observación. ¡Gracias!
J42161217
@CSM desafortunadamente f [3] necesita ser definido. De lo contrario, la fórmula devuelve resultados incorrectos
J42161217
9

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

anatolyg
fuente
8

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!

Emigna
fuente
8

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

Kirill L.
fuente
1
~=n->factorial(big(n))-> ~n=prod(big,1:n)y (24576*~12)^(n%2)->^(24576*~12,n%2)
H.PWiz
¿Por qué usas en ~=n->lugar de ~n=?
H.PWiz
@ H.PWiz, simplemente porque ni siquiera sabía que funcionaría de esta manera, y tampoco lo noté en tu comentario anterior :)
Kirill L.
6

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!

alephalpha
fuente
2
63 bytes . Estaba a punto de publicar el mío basado en la fórmula "trig" de Mowla, pero resultó ser idéntico a esto ...
attinat
6

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!

Arnauld
fuente
6

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.

Neil
fuente
5

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

Galen Ivanov
fuente
1
Se podría cambiar la definen para un λ (2 bytes), y el uso de un valor predeterminado para un parámetro adicional para guardar 3 bytes más de las tres exptllamadas: (λ(n[e expt])...(e ...)...).
fede s.
@fedes. ¡Gracias!
Galen Ivanov
4

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

GotCubes
fuente
Se pueden guardar 2 bytes reemplazando 3**6con 729 y 2**10con 1024 TIO
Herman L
¡Hola, buena captura!
GotCubes
Definir su propia función factorial es 3 bytes más corto
ovs
103 bytes con valores factoriales codificados
ovs
4

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

Jonathan Allan
fuente
3

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:

una(norte)={1 Si norte{0 0,1}7 7!×36 6 Si norte=2una(norte-1)×3×12!×213 Si norte=3una(norte-2)×(24!246 6)norte-2×246 6 Si norte>3
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.

Peter Taylor
fuente
2

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!

Galen Ivanov
fuente
2

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!

LambdaBeta
fuente
1
Sugerir en N--*--N/4lugar de (N*N-2*N)/4y eliminar N-=2y#define s mpz_init_set_str
ceilingcat
2

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!

Zylviij
fuente
1
24576es más corto que2^13*3
H.PWiz
1
74 bytes intentarlo en línea!
Max Yekhlakov
1

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.

Zylviij
fuente
1
Aquí hay 2 bytes fáciles:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz
1
O, mejor aún,÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz
1

ingrese la descripción de la imagen aquí

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/

CSM
fuente
¿Podría agregar una captura de pantalla del n=10caso de prueba para que pueda verificar que funciona? ¿Supongo que no hay forma de hacer que esto funcione en C ++ (clang) o C ++ (gcc) TIO debido a la biblioteca utilizada?
Kevin Cruijssen
Argg. No funciona para valores impares de n
CSM
1
Gracias por la captura de pantalla, y me alegro de que hayas podido identificar el error y solucionarlo. +1 de mi parte :)
Kevin Cruijssen
1
182 bytes
ceilingcat
Ta @ceilingcat. El #define return ya no es necesario, ya que solo hay dos puntos de retorno
CSM
1

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
Scott Milner
fuente