Jumlah permutasi pada NxNxN Rubik's Cube

35

Pengantar:

Kubus Rubik 3x3x3 memiliki kemungkinan permutasi, yaitu sekitar 43 triliun . Anda mungkin pernah mendengar tentang nomor ini sebelumnya, tetapi bagaimana cara menghitungnya?43,252,003,274,489,856,000

Kubus Rubik 3x3x3 memiliki enam sisi, masing-masing dengan sembilan stiker. Melihat pada potongan (eksternal) alih-alih stiker, kami memiliki enam bagian tengah; potongan delapan sudut; dan dua belas potongan tepi. Karena pusat tidak dapat dipindahkan, kami dapat mengabaikannya dalam perhitungan. Adapun sudut dan tepi:

  • Ada( ) cara untuk mengatur delapan sudut. Setiap sudut memiliki tiga kemungkinan orientasi, walaupun hanya tujuh (dari delapan) yang dapat diorientasikan secara independen; orientasi sudut delapan / final tergantung pada tujuh sebelumnya, diberikan ( ) kemungkinan.8!40,320372,187
  • Ada ( ) cara untuk mengatur dua belas tepi. Dibelah dua dariadalah karena ujung harus selalu dalam permutasi genap persis ketika sudut-sudutnya. Sebelas tepi dapat dibalik secara independen, dengan flip kedua belas / tepi akhir tergantung pada sebelas sebelumnya, diberikan ( ) kemungkinan.12!2239,500,80012!2112,048

Menyatukan ini, kami memiliki rumus berikut:

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

Sumber: Wikipedia - Permutasi Kubus Rubik

Meskipun ini mungkin sudah terlihat cukup kompleks, itu masih agak lurus ke depan untuk 3x3x3 Cube. Bahkan untuk kubus rumusnya sedikit berbeda; ini adalah rumus untuk Cube 4x4x4 misalnya:

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

Yaitu sekitar 7,40 quattuordecillion pada skala pendek .

Dan untuk NxNxN Cubes yang lebih besar (yaitu Rekor Dunia 33x33x33 saat ini) formula akan diperpanjang sedikit. Untuk tidak membuat pengantar ini terlalu lama, saya meletakkan tautan ini di sini, di mana permutasi dari 4x4x4 Cube dan beberapa NxNxN Cubes berukuran lain dijelaskan dengan rumus yang dihasilkan:

Anda mungkin bertanya-tanya sekarang: apakah ada rumus umum berdasarkan untuk setiap x x Cube? Pasti ada. Berikut adalah tiga algoritma yang sangat berbeda, semuanya memberikan hasil yang sama persis berdasarkan :NNNNN

1: Formula Chris Hardwick:

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

Cobalah di WolframAlpha.

2: Formula trigonometri Christopher Mowla:

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

Cobalah di WolframAlpha.

3: Formula dasar Christopher Mowla:

212×(2×N×(N+7)-17-11×(-1)N)×3N×(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)

di mana adalah .96577(13×17×19×23)

Cobalah di WolframAlpha.

Sumber: Cubers-reddit - Rumus Penghitungan Matematika dari Jumlah Posisi, Nomor Tuhan, dll.

Tantangan:

Pilih dan terapkan salah satu dari tiga rumus ini (atau turunan Anda sendiri), yang diberi bilangan bulat input dalam kisaran , menghasilkan hasil yang benar.N[2,100]

Aturan tantangan:

  • Anda bebas menggunakan formula lain di samping ketiganya, tetapi perlu diingat bahwa ketiganya terbukti benar. Jika Anda menggunakan formula lain, silakan tambahkan tautan dari mana Anda mendapatkannya (atau jika Anda datang sendiri, tambahkan penjelasan mendalam). Dan saya akan memeriksa semua bilangan bulat dalam kisaran jika outputnya benar. Mungkin inspirasi dapat ditemukan di oeis untuk urutan ini: A075152 .
  • Jika bahasa Anda secara otomatis menampilkan keluaran ilmiah (yaitu alih-alih angka setelah rumus 4x4x4) ini diperbolehkan. Tetapi tolong tambahkan kode tambahan untuk jawaban Anda untuk mengonversi pembulatan ilmiah ini menjadi keluaran yang tepat sehingga hasilnya dapat diverifikasi, karena kesalahan pembulatan karena presisi titik mengambang selama pelaksanaan rumus dalam kode Anda tidak diperbolehkan - hasil yang sebenarnya harus tepat.1.401 ...×1045
  • Program / fungsi Anda harus benar untuk setidaknya input dalam kisaran (walaupun, karena sudah menghasilkan angka yang sangat besar, lebih besar mungkin akan bekerja juga jika Anda dapat menampilkan ini satu dengan benar).[2,100]N=100N
  • Anda tidak diizinkan untuk mengulang semua permutasi yang mungkin dengan penghitung, karena itu tidak akan pernah menghasilkan apa pun dalam jumlah waktu yang wajar. Hanya penerapan formula (salah satu dari tiga yang disediakan, turunan dari salah satu dari itu, atau formula yang sama sekali baru), atau metode lain yang akan memberikan hasil yang benar dalam jumlah waktu yang wajar (tanpa tentu saja hard-coding tentu saja ) Diperbolehkan. Saya berpikir tentang menambahkan waktu untuk memberlakukan ini, tapi saya pribadi menentang dalam kombinasi dengan , jadi saya tidak akan melakukannya. Tetap saja, pastikan program Anda memberikan jawaban, dan jika terlalu lambat untuk TIO karena alasan tertentu, tambahkan beberapa tangkapan layar dengan output dari mesin lokal Anda sebagai verifikasi.

Aturan umum:

  • Ini adalah , jadi jawaban tersingkat dalam byte menang.
    Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa yang bukan kode. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman 'apa saja'.
  • Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu.
  • Celah default tidak diperbolehkan.
  • Jika memungkinkan, silakan tambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
  • Juga, menambahkan penjelasan untuk jawaban Anda sangat dianjurkan.

Kasus uji:

Di sini kasus uji untuk dalam kisaran (jangan ragu untuk menggunakan tautan WolframAlpha di atas untuk kasus uji yang lebih besar):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

CATATAN: Karena ini adalah tantangan , pada dasarnya bermuara pada: mengimplementasikan salah satu dari tiga rumus ini (atau turunan / metode Anda sendiri yang masih menghasilkan hasil yang benar) sesingkat mungkin.

Kevin Cruijssen
sumber
2
Melakukan ini di x86-64 akan menjadi tantangan yang menyenangkan. Saya harus memutar bigint saya sendiri (kemungkinan hanya int 256-bit atau 512-bit), dan membuatnya menjadi golf.
moonheart08
4
Perhatikan bahwa rumus "trigon" Mowla hanya menggunakan dan cos 2 untuk mengaburkan s. dosa2cos2floor
attinat
4
@attinat, saya pikir ini adalah perspektif yang lebih berguna untuk mengatakan bahwa baik trigonometri dan lantainya mengaburkan Nmod2
Peter Taylor
2
@ChristopherMowla Jangan menganggap komentar mereka pribadi. Saya kagum bahwa Anda dapat menemukan formula ini dan membuat prediksi yang akurat di tempat pertama, dan formula Anda adalah salah satu inspirasi untuk tantangan ini. Ini adalah kode-golf, jadi keterbacaan, kinerja, peringatan, praktik terbaik, signifikansi historis, dan kadang-kadang hanya akal sehat semua dilemparkan ke laut jika dapat menyimpan satu byte pada jawaban. ;) attinat dan PeterTaylor hanya menyarankan golf seperti itu berdasarkan pada formula Anda, karena N mod 2 sedikit lebih pendek untuk digunakan dalam bahasa pemrograman daripada trigonometri.
Kevin Cruijssen

Jawaban:

12

Bahasa Wolfram (Mathematica) , 59 byte

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

Cobalah online!

menggunakan algoritma Herbert Kociemba yang ditemukan di halaman OEIS

di sini adalah rumus rekursif:
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 byte disimpan oleh @Peter Taylor

satu byte lagi disimpan oleh @Expired Data

J42161217
sumber
65 byte
Expired Data
@ExpiredData sangat bagus! Saya mencoba melakukan hal yang sama tetapi gagal karena urutannya berbeda
J42161217
Pertanyaannya tidak mengharuskan Anda untuk mendukung f@1, sehingga Anda dapat menghemat 6 byte. Tentunya Anda juga ingin menyesuaikan kerangka pengujian untuk digunakan Range[2,10].
Peter Taylor
@PeterTaylor pengamatan yang bagus. Terima kasih!
J42161217
@CSM unfortynately f [3] perlu didefinisikan. Jika tidak rumus ini mengembalikan hasil yang salah
J42161217
9

kode mesin x86, 119 byte

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

Fungsi menerima jumlah ndalam ecx, dan pointer ke string untuk mengisi edx(yaitu fastcallkonvensi).

Sebelum saya menunjukkan kode sumber, beberapa penjelasan tentang bagaimana melakukan hal itu. Ini menggunakan rumus rekursif, yang saya tulis dengan cara berikut:

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

Jadi semua kode yang harus dilakukan adalah perkalian dengan angka kecil. Jumlahnya berada di kisaran 6 ... 36, yang cukup kecil untuk diwakili dalam bitmap 32-bit. Saya sebenarnya tidak menyimpan bit yang mewakili perkalian dengan 6 - ini memungkinkan saya mengatur kode dalam satu do-whilelingkaran, dimulai dengan perkalian tanpa syarat dengan 6.

Angka-angka besar diwakili menggunakan bentuk desimal - setiap byte adalah nilai dalam rentang 0 ... 9, mulai dari MSB.

Perkalian dilakukan dari LSB ke MSB; itu mengasumsikan bahwa jumlah digit akan bertambah 2 untuk setiap perkalian. Setelah melakukan perkalian dengan faktor kecil seperti 6, jumlah digit dapat tumbuh hanya 1. Jadi, jika MSB = 0, itu akan memindahkan seluruh hasil antara yang tersisa. Dapat benar-benar terjadi bahwa jumlah digit tidak tumbuh sama sekali, dan kemudian MSB akan tetap 0, tetapi masalah ini akan memperbaiki dirinya sendiri ketika kode berlanjut ke faktor yang lebih besar.

Karena kode multiplikasi besar, saya tidak ingin memasukkannya dua kali. Saya juga tidak ingin memindahkannya ke suatu fungsi, karena kode mesin untuk memanggil suatu fungsi besar. Jadi saya mengatur ulang loop luar sedemikian rupa sehingga kode pengali hanya diperlukan sekali.

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

Membongkar:

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;

Waktu berjalan untuk n = 100 adalah sekitar 4 detik, dan hasilnya adalah angka dengan 38416 digit:

23491019577617 (banyak digit di sini) ... (banyak nol di sini) 000000000000000000

anatolyg
sumber
8

05AB1E , 38 byte

Upaya awal.
Menggunakan Formula Chris Hardwick .
Akan berusaha bermain golf lebih jauh dan menjelaskan kapan saya punya waktu.

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

Cobalah online!

Emigna
sumber
8

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)

Cobalah online!

Menggunakan Formula Chris Hardwick. Mengambil input sebagai bilangan bulat besar.

Terima kasih kepada H.PWiz untuk -7 byte

Kirill L.
sumber
1
~=n->factorial(big(n))-> ~n=prod(big,1:n)dan (24576*~12)^(n%2)->^(24576*~12,n%2)
H.PWiz
Mengapa Anda menggunakan ~=n->bukan ~n=?
H.PWiz
@ H.PWiz, hanya karena saya bahkan tidak tahu itu akan bekerja seperti ini, dan juga tidak menyadari bahwa dalam komentar Anda sebelumnya :)
Kirill L.
7

Python 2 , 72 byte

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

Cobalah online!

Disimpan 4 byte dengan menyalin n*(n-2)/4dari Neil .

Tidak
sumber
6

Bahasa Wolfram (Mathematica) , 67 byte

Menggunakan Formula Chris Hardwick.

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

Cobalah online!

alephalpha
sumber
2
63 byte . Akan memposting milikku berdasarkan formula "trig" Mowla, tetapi ternyata identik dengan ini ...
attinat
6

JavaScript (Node.js) , 81 byte

Formula rekursif Herbert Kociemba. Mengambil BigInt sebagai input.

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

Cobalah online!


JavaScript (Node.js) ,  102 98  96 byte

Formula Chris Hardwick. Mengambil BigInt sebagai input.

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

Cobalah online!

Arnauld
sumber
6

JavaScript (Node.js) , 77 75 73 byte

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

Cobalah online! Berdasarkan formula Christopher Mowla. Mengambil BigInt sebagai input. Uji harness tanpa malu-malu dicuri dari @Arnauld 0xb88d4641131f0nadalah 3246670537110000ndalam desimal. Penjelasan: Saya mulai dengan eksponen utama terakhir dan menyederhanakannya n*(n-2n)/4n(ini adalah pembagian bilangan bulat, jadi saya tidak perlu penyesuaian untuk angka ganjil). Saya kemudian memeriksa bilangan prima lainnya untuk melihat apakah eksponen mereka terkait dengan nilai ini (yang akan saya sebut sebagai o), dan menemukan bahwa mereka mengejar mode, jika saya mengizinkan penggunaan paritas n(yang saya sebut sebagai p). Rumus untuk eksponen adalah sebagai berikut:

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

Kekuatan kemudian dapat dikelompokkan berdasarkan eksponen jadi misalnya padalah eksponen 11*7*5**2*3**3*2**14.

Neil
sumber
5

Racket , 151 141 byte

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

Cobalah online!

Jawaban terpanjang menggunakan Formula Chris Hardwick :)

Galen Ivanov
sumber
1
Anda bisa mengubah menentukan untuk λ (2 byte), dan menggunakan nilai default untuk parameter tambahan untuk menyimpan 3 byte lebih dari tiga exptpanggilan: (λ(n[e expt])...(e ...)...).
fede s.
@ Feder. Terima kasih!
Galen Ivanov
4

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)

Cobalah online!

Menggunakan metode rekursif Herbert Kociemba.

-2 byte terima kasih kepada Herman L

GotCubes
sumber
2 byte dapat disimpan dengan mengganti 3**6dengan 729 dan 2**10dengan 1024 TIO
Herman L
Hei, tangkapan bagus!
GotCubes
Mendefinisikan fungsi faktorial Anda sendiri adalah 3 byte lebih pendek
ovs
103 byte dengan nilai faktorial hardcoded
ovs
4

Jelly ,  39  38 byte

Saya merasa seperti melewatkan beberapa golf, tapi ...

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

Tautan monadik yang menerapkan Formula Chris Hardwick.

Cobalah online! Atau lihat test-suite (n=[1..33]).

Jonathan Allan
sumber
3

CJam (47 byte)

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

Demo online

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

Peter Taylor
sumber
2

Ikon , 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

Cobalah online!

Galen Ivanov
sumber
2

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

Cobalah online!

LambdaBeta
sumber
1
Sarankan N--*--N/4alih-alih (N*N-2*N)/4dan hapus N-=2dan#define s mpz_init_set_str
ceilingcat
2

Perl 6 , 85 byte

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

Cobalah online!

bb94
sumber
2

Haskell , 86 85 74 byte

-1 byte disimpan berkat H.PWiz
-11 byte yang disimpan berkat 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)

Cobalah online!

Zylviij
sumber
1
24576lebih pendek dari2^13*3
H.PWiz
1
74 byte Cobalah secara online!
Max Yekhlakov
1

Python 2 , 92 byte

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

Cobalah online!

pengguna24343
sumber
1

Sekam , 51 48 44 byte

-4 byte terima kasih kepada H.PWiz

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

Cobalah online!

Ini adalah Formula Chris Hardwick. Juga, ini adalah program kulit pertama saya, jadi tips apa pun akan sangat dihargai.

Zylviij
sumber
1
Berikut ini adalah 2 byte yang mudah:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz
1
Atau, lebih baik lagi,÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz
1

masukkan deskripsi gambar di sini

C ++, 187 185 180 176 195 (ada bug) 193 175 bytes (dengan bantuan dari ceiling cat)

Ini menggunakan pembungkus GMP C ++ (GNU multi-precision library), dan formula yang digunakan oleh @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Gunakan g++ -g rubix.cpp -lgmp -lgmpxxuntuk mengkompilasi dan menautkan

#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, dengan kode uji

#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
sumber
Bisakah Anda menambahkan tangkapan layar dari n=10test case, jadi saya dapat memverifikasi bahwa itu berfungsi? Saya kira tidak ada cara untuk membuat ini bekerja pada C ++ (clang) atau C ++ (gcc) TIO karena pustaka yang digunakan?
Kevin Cruijssen
argg. Ini tidak berfungsi untuk nilai ganjil dari n
CSM
1
Terima kasih atas tangkapan layarnya, dan bagus bahwa Anda dapat menentukan kesalahan dan memperbaikinya. +1 dari saya. :)
Kevin Cruijssen
1
182 byte
ceilingcat
Ta @ceilingcat. Pengembalian #define tidak diperlukan lagi, karena hanya ada dua poin kembali
CSM
1

TI-BASIC, 63 62 byte , (tidak bersaing)

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

Ekspresi yang menerima input sebagai integer aktif Ans. Penerapan formula Chris Hardwick. Tidak bersaing karena perangkat keras yang dijalankannya hanya akan menyimpan hingga 16 desimal, jadi jawabannya tidak akan pernah 100% akurat.

Penjelasan:

{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
sumber