Ilość permutacji na kostce Rubika NxNxN

35

Wprowadzenie:

Kostka Rubika 3x3x3 ma możliwych , co stanowi około 43 kwintillionów . Być może słyszałeś już o tej liczbie, ale jak to się faktycznie liczy?43,252,003,274,489,856,000

Kostka Rubika 3x3x3 ma sześć stron, każda z dziewięcioma naklejkami. Jednak patrząc na (zewnętrzne) elementy zamiast naklejek, mamy sześć elementów środkowych; osiem narożników; i dwanaście kawałków krawędzi. Ponieważ centrów nie można przenieść, możemy zignorować je w obliczeniach. Jeśli chodzi o rogi i krawędzie:

  • Jest(40 ) sposobów na ustawienie ośmiu rogów. Każdy narożnik ma trzy możliwe orientacje, chociaż tylko siedem (z ośmiu) można ustawić niezależnie; orientacja ósmego / końcowego rogu zależy od poprzednich siedmiu, biorąc pod uwagę ( ) możliwości.8!40,320372,187
  • Istnieją ( ) sposobów na ułożenie dwunastu krawędzi. Połówka zponieważ krawędzie muszą zawsze znajdować się w równej permutacji dokładnie wtedy, gdy są narożniki. Jedenaście krawędzi można odwracać niezależnie, z odwróceniem krawędzi dwunastej / końcowej w zależności od poprzedzającej jedenastki, biorąc pod uwagę ( ) możliwości.12!2239,500,80012!2112,048

Podsumowując, mamy następującą formułę:

8!×37×12!2×211=43,252,003,274,489,856,000

Źródło: Wikipedia - Permutacje kostki Rubika

Chociaż może to już wyglądać dość skomplikowane, wciąż jest dość proste jak na kostkę 3x3x3. W przypadku nawet kostek formuła jest nieco inna; oto wzór na kostkę 4x4x4 na przykład:

8!×37×24!2247=7,401,196,841,564,901,869,874,093,974,498,574,336,000,000,000

To jest około 7,40 quattuordecillion w krótkiej skali .

A w przypadku większych kostek NxNxN (tj. Aktualny rekord świata 33x33x33) formuła zostanie nieco rozszerzona. Aby jednak nie wprowadzać tego wprowadzenia zbyt długo, umieściłem tutaj te linki, gdzie wyjaśniono permutacje kostki 4x4x4 i innych kostek NxNxN o innych rozmiarach z uzyskaną formułą:

Być może już się zastanawiasz: czy istnieje ogólna formuła oparta na dla dowolnej kostki x x ? Z pewnością jest. Oto trzy zupełnie różne algorytmy, z których wszystkie dają dokładnie takie same wyniki w oparciu o :NNNNN

1: Formuła Chrisa Hardwicka:

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

Wypróbuj na WolframAlpha.

2: Formuła trig Christophera Mowli:

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

Wypróbuj na WolframAlpha.

3: Liczby pierwsze Christophera Mowli Wzór:

2)12)×(2)×N.×(N.+7)-17-11×(-1)N.)×3)N.×(N.+1)+2)×512)×(2)×N.×(N.-2))+1+(-1)N.)×718×(6×N.×(N.-2))+3)+5×(-1)N.)×1114×(2)×N.×(N.-2))-1+(-1)N.)×9657718×(2)×N.×(N.-2))-3)+3)×(-1)N.)

gdzie to .96577(13×17×19×23)

Wypróbuj na WolframAlpha.

Źródło: Cubers-reddit - Matematyczne formuły liczenia liczby pozycji, liczby Boga itp.

Wyzwanie:

Wybierz i zaimplementuj jedną z tych trzech formuł (lub własną pochodną), która podając liczbę całkowitą wejściową w zakresie , daje prawidłowy wynik.N.[2),100]

Zasady konkursu:

  • Możesz użyć innej formuły oprócz tych trzech, ale pamiętaj, że te trzy okazały się poprawne. Jeśli używasz innej formuły, dodaj link, skąd ją masz (lub jeśli sam ją wymyślisz, dodaj dogłębne wyjaśnienie). I sprawdzę, czy wszystkie liczby całkowite w zakresie są prawidłowe. Być może inspirację można znaleźć w Oeis dla tej sekwencji: A075152 .
  • Jeśli twój język automatycznie generuje wyniki naukowe (tj. zamiast liczby po formule 4x4x4), jest to dozwolone. Ale proszę dodać dodatkowy kod do swojej odpowiedzi, aby przekonwertować to zaokrąglenie naukowe na dokładny wynik, aby można było zweryfikować wyniki, ponieważ błędy zaokrąglania wynikające z precyzji zmiennoprzecinkowej podczas wykonywania formuły w kodzie są niedozwolone - rzeczywisty wynik powinien być dokładny.1.401 ...×1045
  • Twój program / funkcja powinna być poprawna co najmniej dla danych wejściowych z zakresu (chociaż, ponieważ już daje ogromną liczbę, każdy większy prawdopodobnie będzie również działał, jeśli będziesz w stanie to wyprowadzić jeden poprawnie).[2),100]N.=100N.
  • Nie można zapętlać wszystkich możliwych kombinacji z licznikiem, ponieważ nigdy nie dałoby to niczego w rozsądnym czasie. Tylko wdrożenie formuły (jednej z trzech podanych, pochodnej jednej z nich lub zupełnie nowej formuły) lub innej metody, która da prawidłowe wyniki w rozsądnym czasie (oczywiście bez twardego kodowania) ) jest dozwolone. Myślałem o dodaniu aby to wymusić, ale osobiście jestem przeciwny w połączeniu z , więc nie zrobię tego. Mimo to upewnij się, że Twój program udziela odpowiedzi, a jeśli z jakiegoś powodu jest zbyt wolny dla TIO, dodaj kilka zrzutów ekranu z danymi wyjściowymi z komputera lokalnego w celu weryfikacji.

Główne zasady:

  • To jest , więc wygrywa najkrótsza odpowiedź w bajtach.
    Nie pozwól, aby języki gry w golfa zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
  • Do odpowiedzi mają zastosowanie standardowe reguły z domyślnymi regułami We / Wy , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami i typem zwracanych, pełnych programów. Twoja decyzja.
  • Domyślne luki są zabronione.
  • Jeśli to możliwe, dodaj link z testem kodu (tj. TIO ).
  • Zalecane jest również dodanie wyjaśnienia do odpowiedzi.

Przypadki testowe:

Oto przypadki testowe dla w zakresie (możesz użyć powyższych linków WolframAlpha dla większych przypadków testowych):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

UWAGA: Ponieważ jest to wyzwanie dla , sprowadza się ono do: wdrożenia jednej z tych trzech formuł (lub pochodnej / własnej metody, która nadal daje prawidłowe wyniki) tak krótko, jak to możliwe.

Kevin Cruijssen
źródło
2
Robienie tego w x86-64 będzie fajnym wyzwaniem. Będę musiał stworzyć własnego biginta (prawdopodobnie tylko 256-bitowy lub 512-bitowy int) i zrobić z niego golfa.
moonheart08
4
Zauważ, że formuła „trig” Mowli używa po prostu i do zaciemnienia s. grzech2)sałata2)floor
attinat
4
@attinat, myślę, że bardziej użyteczna perspektywa mówi, że zarówno trygon, jak i podłogi zaciemniająN.mod2)
Peter Taylor
2
@ChristopherMowla Nie traktuj swoich komentarzy osobiście. Dziwi mnie, że udało ci się znaleźć te formuły i przede wszystkim dokonać tak dokładnych prognoz, a twoje formuły były jedną z inspiracji tego wyzwania. Jest to jednak golf golfowy, więc czytelność, wydajność, ostrzeżenia, najlepsze praktyki, znaczenie historyczne, a czasem po prostu zdrowy rozsądek są wyrzucane za burtę, jeśli można zaoszczędzić jeden bajt na odpowiedzi. ;) attinat i PeterTaylor po prostu zasugerowali taki golf w oparciu o twoje formuły, ponieważ N mod 2 jest nieco krótszy w użyciu w językach programowania niż trig.
Kevin Cruijssen

Odpowiedzi:

12

Wolfram Language (Mathematica) , 59 bajtów

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

Wypróbuj online!

wykorzystuje algorytm Herberta Kociemby znaleziony na stronie OEIS

oto rekurencyjna formuła:
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 bajtów zapisanych przez @Peter Taylor

jeszcze jeden bajt zapisany przez @Expired Data

J42161217
źródło
65 bajtów
data ważności wygasła
@ExpiredData bardzo miło! Próbowałem zrobić to samo, ale nie udało się, ponieważ kolejność była inna
J42161217
Pytanie nie wymaga wsparcia f@1, więc możesz zapisać 6 bajtów. Oczywiście chciałbyś również dostosować swoją strukturę testową do użycia Range[2,10].
Peter Taylor,
@PeterTaylor świetna obserwacja. dzięki!
J42161217
@CSM niepotrzebnie należy zdefiniować f [3], w przeciwnym razie formuła zwróci nieprawidłowe wyniki
J42161217
9

kod maszynowy x86, 119 bajtów

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

Funkcja otrzymuje numer nw ecxoraz wskaźnik do łańcucha znaków do wypełnienia edx(czyli fastcallkonwencja).

Zanim pokażę kod źródłowy, kilka wyjaśnień, jak to działa. Wykorzystuje formułę rekurencyjną, którą napisałem w następujący sposób:

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

Więc wszystko, co powinien zrobić kod, to pomnożenie przez małe liczby. Liczby mieszczą się w zakresie 6 ... 36, który jest wystarczająco mały, aby można go było przedstawić w 32-bitowej mapie bitowej. Właściwie nie przechowuję bitu reprezentującego mnożenie przez 6 - pozwala mi to ułożyć kod w do-whilepętli, zaczynając od bezwarunkowego pomnożenia przez 6.

Duże liczby są reprezentowane przy użyciu postaci dziesiętnej - każdy bajt jest wartością z zakresu 0 ... 9, zaczynając od MSB.

Mnożenie odbywa się z LSB do MSB; zakłada, że ​​liczba cyfr wzrośnie o 2 dla każdego pomnożenia. Po pomnożeniu przez mały współczynnik, taki jak 6, liczba cyfr może wzrosnąć tylko o 1. Więc jeśli MSB = 0, przesuwa cały wynik pośredni w lewo. Może się zdarzyć, że liczba cyfr w ogóle się nie zwiększy, a wtedy MSB będzie nadal wynosić 0, ale ten problem sam się rozwiąże, gdy kod przejdzie na większe czynniki.

Ponieważ kod mnożenia jest duży, nie chcę go umieszczać dwa razy. Nie chcę też przenosić go do funkcji, ponieważ kod maszynowy do wywoływania funkcji jest duży. Przestawiłem więc zewnętrzne pętle w taki sposób, że kod mnożenia jest potrzebny tylko raz.

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

Demontaż:

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;

Czas działania dla n = 100 wynosi około 4 sekund, a wynikiem jest liczba z 38416 cyframi:

23491019577617 (wiele cyfr tutaj) ... (wiele zer tutaj) 0000000000000000

anatolig
źródło
8

05AB1E , 38 bajtów

Pierwsza próba.
Wykorzystuje formułę Chrisa Hardwicka .
Spróbuję dalej grać w golfa i wyjaśnię, kiedy będę miał czas.

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

Wypróbuj online!

Emigna
źródło
8

Julia 1.0 , 83 76 bajtów

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

Wypróbuj online!

Wykorzystuje formułę Chrisa Hardwicka. Pobiera dane wejściowe jako Big integer.

Dzięki H.PWiz za -7 bajtów

Kirill L.
źródło
1
~=n->factorial(big(n))-> ~n=prod(big,1:n)i (24576*~12)^(n%2)->^(24576*~12,n%2)
H.PWiz
Dlaczego używasz ~=n->zamiast ~n=?
H.PWiz
@ H.PWiz, po prostu dlatego, że nawet nie wiedziałem, że zadziała w ten sposób, a także nie zauważyłem tego w poprzednim komentarzu :)
Kirill L.,
6

Wolfram Language (Mathematica) , 67 bajtów

Korzystanie z formuły Chrisa Hardwicka.

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

Wypróbuj online!

alephalpha
źródło
2
63 bajty . Już miał opublikować mój w oparciu o formułę „trig” Mowli, ale okazało się, że jest identyczny z tym ...
attinat
6

JavaScript (Node.js) , 81 bajtów

Recursywna formuła Herberta Kociemby. Pobiera BigInt jako wejście.

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

Wypróbuj online!


JavaScript (Node.js) ,  102 98  96 bajtów

Wzór Chrisa Hardwicka. Pobiera BigInt jako wejście.

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

Wypróbuj online!

Arnauld
źródło
6

JavaScript (Node.js) , 77 75 73 bajtów

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

Wypróbuj online! Na podstawie formuły Christophera Mowli. Pobiera BigInt jako wejście. Uprząż testowa bezwstydnie skradziona z @Arnauld. 0xb88d4641131f0njest 3246670537110000nw systemie dziesiętnym. Objaśnienie: Zacząłem od ostatniego wykładnika głównego i uprościłem go n*(n-2n)/4n(jest to podział na liczby całkowite, więc nie potrzebuję korekty liczb nieparzystych). Następnie zbadałem pozostałe liczby pierwsze, aby sprawdzić, czy ich wykładniki są powiązane z tą wartością (którą będę określał jako o), i stwierdziłem, że były one modne, jeśli pozwolę na użycie parzystości n(którą będę określał jako p). Formuły wykładników są następujące:

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

Moce mogą być następnie pogrupowane według wykładnika, więc na przykład pjest wykładnikiem wykładnika 11*7*5**2*3**3*2**14.

Neil
źródło
5

Rakieta , 151 141 bajtów

-7 bajtów dzięki 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))))

Wypróbuj online!

Najdłuższa odpowiedź przy użyciu Formuły Chrisa Hardwicka :)

Galen Iwanow
źródło
1
Można zmienić zdefiniować dla Î (2 bajty) i używać wartości domyślnej dla dodatkowego parametru, aby zapisać 3 kolejne bajty z trzech exptpołączeń: (λ(n[e expt])...(e ...)...).
fede s.
@fedes. Dzięki!
Galen Iwanow
4

Python 2 , 122 bajty

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)

Wypróbuj online!

Wykorzystuje metodę rekurencyjną Herberta Kociemby.

-2 bajty dzięki Hermanowi L.

GotCubes
źródło
2 bajty mogą być zapisywane poprzez wymianę 3**6z 729 i 2**10z 1024 TIO
Herman L
Hej, niezły chwyt!
GotCubes
Definiowanie własnych funkcji silni jest 3 bajty krótszy
OVS
103 bajty z zakodowanymi wartościami
silniowymi
4

Galaretka ,  39  38 bajtów

Czuję, że przegapiłem kilka golfów, ale ...

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

Monadyczny link implementujący Formułę Chrisa Hardwicka.

Wypróbuj online! Lub zobacz test-suite (n=[1..33]).

Jonathan Allan
źródło
3

CJam (47 bajtów)

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

Demo online

za(n)={1 Jeśli n{0,1}7!×3)6 Jeśli n=2)za(n-1)×3)×12!×2)13 Jeśli n=3)za(n-2))×(24!246)n-2)×246 Jeśli n>3)
j

Peter Taylor
źródło
2

Ikona , 125 110 bajtów

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

Wypróbuj online!

Galen Iwanow
źródło
2

C (gcc) -lgmp, 279 bajtów

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

Wypróbuj online!

LambdaBeta
źródło
1
Zaproponuj N--*--N/4zamiast (N*N-2*N)/4i usuń N-=2i#define s mpz_init_set_str
ceilingcat
2

Perl 6 , 85 bajtów

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

Wypróbuj online!

bb94
źródło
2

Haskell , 86 85 74 bajtów

-1 bajt zapisany dzięki H.PWiz
-11 bajtów zapisany dzięki 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)

Wypróbuj online!

Zylviij
źródło
1
24576jest krótszy niż2^13*3
H.PWiz
1
74 bajty Wypróbuj online!
Max Yekhlakov
1

Python 2 , 92 bajty

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

Wypróbuj online!

użytkownik24343
źródło
1

Łuska , 51 48 44 bajtów

-4 bajty dzięki H.PWiz

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

Wypróbuj online!

To Formuła Chrisa Hardwicka. To także mój pierwszy program łuskowy, więc wszelkie wskazówki byłyby mile widziane.

Zylviij
źródło
1
Oto łatwe 2 bajty:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz
1
Lub jeszcze lepiej÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz
1

wprowadź opis zdjęcia tutaj

C ++, 187 185 180 176 195 (wystąpił błąd) 193 175 bajtów (z pomocą kota na suficie)

Wykorzystuje to opakowanie GMP C ++ (biblioteka wieloprecyzyjna GNU) oraz formułę używaną przez @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Służy g++ -g rubix.cpp -lgmp -lgmpxxdo kompilowania i łączenia

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

bez golfa, z kodem testowym

#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
źródło
Czy możesz dodać zrzut ekranu n=10przypadku testowego, aby sprawdzić, czy działa? Wydaje mi się, że nie ma sposobu, aby to działało na CIO (clang) lub C ++ (gcc) TIO z powodu używanej biblioteki?
Kevin Cruijssen
argument Nie działa dla nieparzystych wartości n
CSM
1
Dzięki za zrzut ekranu i dobrze, że udało ci się zlokalizować błąd i go naprawić. +1 ode mnie :)
Kevin Cruijssen
1
182 bajty
pułapkap
Ta @ceilingcat. Zwrot #define nie jest już potrzebny, ponieważ istnieją tylko dwa punkty zwrotu
CSM
1

TI-BASIC, 63 62 bajtów , (niekonkurencyjny)

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

Wyrażenie, które przyjmuje dane wejściowe jako liczbę całkowitą Ans. Wdrożenie formuły Chrisa Hardwicka. Niekonkurencyjny, ponieważ sprzęt, na którym działa, zapisze tylko 16 miejsc po przecinku, więc odpowiedź nigdy nie będzie w 100% dokładna.

Wyjaśnienie:

{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
źródło