Quantidade de permutações em um cubo de NxNxN Rubik

35

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

Juntando isso, temos a seguinte fórmula:

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

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

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

1: Fórmula de Chris Hardwick:

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

Experimente no WolframAlpha.

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

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

Experimente no WolframAlpha.

3: Primos de Christopher Mowla Fórmula:

21 12×(2×N×(N+7)-17-11×(-1 1)N)×3N×(N+1 1)+2×51 12×(2×N×(N-2)+1 1+(-1 1)N)×71 18×(6×N×(N-2)+3+5×(-1 1)N)×111 14×(2×N×(N-2)-1 1+(-1 1)N)×965771 18×(2×N×(N-2)-3+3×(-1 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 ...×1045
  • 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=100N
  • 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 para impor isso, mas pessoalmente sou contra o em combinação com o , 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 é , 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 , 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.

Kevin Cruijssen
fonte
2
Fazer isso no x86-64 será um desafio divertido. Vou ter que rolar meu próprio bigint (provavelmente apenas um int de 256 bits ou 512 bits) e torná-lo um golf.
moonheart08
4
Observe que a fórmula "trig" de Mowla apenas usa e cos 2 para ofuscar s. pecado2porque2floor
attinat 18/04
4
@attinat, acho que é uma perspectiva mais útil dizer que tanto o trig e o piso estão ofuscando o Nmod2
Peter Taylor
2
@ChristopherMowla Não tome seus comentários pessoais. Estou surpreso que você tenha conseguido encontrar essas fórmulas e tenha feito previsões tão precisas em primeiro lugar, e suas fórmulas foram uma das inspirações para esse desafio. No entanto, isso é código-golfe, portanto, legibilidade, desempenho, avisos, práticas recomendadas, significado histórico e, às vezes, apenas senso comum são jogados fora, se você pode salvar um único byte em uma resposta. ;) attinat e PeterTaylor simplesmente sugeriram esse tipo de golfe com base em suas fórmulas, pois o N mod 2 é um pouco mais curto para usar em linguagens de programação que o trig.
Kevin Cruijssen 23/04

Respostas:

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

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

J42161217
fonte
65 bytes
Dados expirados
@ExpiredData very nice! Eu estava tentando fazer o mesmo, mas falhou porque o pedido era diferente
J42161217 17/04
A pergunta não requer suporte f@1, portanto, você pode salvar 6 bytes. Obviamente, você também gostaria de ajustar sua estrutura de teste para usar Range[2,10].
Peter Taylor
@PeterTaylor ótima observação. obrigado!
J42161217 18/04
@CSM infelizmente não é necessário definir f [3]. Caso contrário, a fórmula retorna resultados incorretos
J42161217 20/04
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

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

anatolyg
fonte
8

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!

Emigna
fonte
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)

Experimente online!

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

Graças a H.PWiz por -7 bytes

Kirill L.
fonte
11
~=n->factorial(big(n))-> ~n=prod(big,1:n)e (24576*~12)^(n%2)->^(24576*~12,n%2)
H.PWiz 17/04
Por que você usa em ~=n->vez de ~n=?
H.PWiz
@ H.PWiz, simplesmente porque eu nem sabia que funcionaria dessa maneira, e também não percebi isso no seu comentário anterior :)
Kirill L.
6

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!

alefalpha
fonte
2
63 bytes . Estava prestes a publicar o meu com base na fórmula "trig" de Mowla, mas acabou sendo idêntica a esta ...
attinat 18/04
6

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!

Arnauld
fonte
6

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.

Neil
fonte
5

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

Galen Ivanov
fonte
11
Você poderia mudar a definição para um λ (2 bytes), e usar um valor padrão para um parâmetro extra para salvar mais 3 bytes das três exptchamadas: (λ(n[e expt])...(e ...)...).
fede s.
@fedes. Obrigado!
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)

Experimente online!

Usa o método recursivo de Herbert Kociemba.

-2 bytes graças a Herman L

GotCubes
fonte
2 bytes podem ser salvos substituindo 3**6por 729 e 2**10por 1024 TIO
Herman L
Ei, boa captura!
GotCubes 17/04
Definir sua própria função fatorial é 3 bytes mais curto
ovs 22/04
103 bytes com valores fatoriais codificados
ovs 22/04
4

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

Jonathan Allan
fonte
3

CJam (47 bytes)

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

Demonstração online

uma(n)={1 1 E se n{0 0,1 1}7!×36 E se n=2uma(n-1 1)×3×12!×213 E se n=3uma(n-2)×(24!246)n-2×246 E se n>3
j

Peter Taylor
fonte
2

Í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!

Galen Ivanov
fonte
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);}

Experimente online!

LambdaBeta
fonte
11
Sugerir em N--*--N/4vez de (N*N-2*N)/4remover N-=2e#define s mpz_init_set_str
ceilingcat 19/04
2

Perl 6 , 85 bytes

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

Experimente online!

bb94
fonte
2

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!

Zylviij
fonte
11
24576é mais curto que2^13*3
H.PWiz
11
74 bytes Experimente online!
Max Yekhlakov 23/04
1

Python 2 , 92 bytes

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

Experimente online!

user24343
fonte
1

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.

Zylviij
fonte
11
Aqui estão 2 bytes fáceis:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz
11
Ou, melhor ainda,÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz
1

insira a descrição da imagem aqui

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/

CSM
fonte
Você poderia adicionar uma captura de tela do n=10caso de teste para que eu possa verificar se ele funciona? Eu acho que não há nenhuma maneira de fazer isso funcionar no CIO (clang) ou C ++ (gcc) TIO devido à biblioteca usada?
Kevin Cruijssen 20/04
argg. Não está funcionando para valores ímpares de n
CSM
11
Obrigado pela captura de tela e bom que você conseguiu identificar o erro e corrigi-lo. +1 de mim. :)
Kevin Cruijssen 20/04
11
182 bytes
ceilingcat 22/04
Ta @ceilingcat. O retorno #define não é mais necessário, pois há apenas dois pontos de retorno
CSM
1

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