Anzahl der Permutationen auf einem NxNxN Rubik's Cube


35

Einführung:

Ein 3x3x3 Rubik's Cube hat mögliche Permutationen, was ungefähr 43 Trillionen entspricht . Sie haben vielleicht schon einmal von dieser Zahl gehört, aber wie wird sie tatsächlich berechnet?43,252,003,274,489,856,000

Ein 3x3x3 Rubik's Cube hat sechs Seiten mit jeweils neun Aufklebern. Betrachtet man jedoch die (äußeren) Teile anstelle von Aufklebern, so hat man sechs Mittelteile; acht Eckstücke; und zwölf Randstücke. Da die Zentren nicht verschoben werden können, können wir diese in den Berechnungen ignorieren. Wie für die Ecken und Kanten:

  • Es gibt( ) Möglichkeiten zum Anordnen der acht Ecken. Jede Ecke hat drei mögliche Ausrichtungen, obwohl nur sieben (von den acht) unabhängig voneinander ausgerichtet werden können. Die Ausrichtung der achten / letzten Ecke hängt von den vorhergehenden sieben ab, wenn ( ) Möglichkeiten gegeben sind.8!40,320372,187
  • Es gibt ( ) Möglichkeiten, die zwölf Kanten anzuordnen. Die Hälfte vonDas liegt daran, dass Kanten immer in einer gleichmäßigen Permutation sein müssen, genau dann, wenn die Ecken sind. Elf Kanten können unabhängig voneinander gespiegelt werden, wobei das Spiegeln der zwölften / letzten Kante von den vorhergehenden elf abhängt, wenn ( ) Möglichkeiten gegeben sind.12!2239,500,80012!2112,048

Zusammen haben wir die folgende Formel:

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

Quelle: Wikipedia - Rubiks Würfel-Permutationen

Obwohl dies bereits recht komplex aussieht, ist es für einen 3x3x3-Würfel immer noch recht unkompliziert. Für gerade Würfel ist die Formel etwas anders; Dies ist die Formel für einen 4x4x4-Würfel, zum Beispiel:

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

Welches ist etwa 7,40 Quattuordecillion auf der kurzen Skala .

Und für größere NxNxN-Würfel (dh den aktuellen Weltrekord 33x33x33) wird die Formel erheblich erweitert. Um diese Einführung nicht zu lang zu machen, habe ich stattdessen diese Links hier eingefügt, wo die Permutationen des 4x4x4-Würfels und einiger NxNxN-Würfel anderer Größe mit der folgenden Formel erklärt werden:

Sie wundern sich jetzt vielleicht: Gibt es eine allgemeine Formel, die auf für einen beliebigen x x Würfel basiert ? Das gibt es sicherlich. Hier sind drei völlig unterschiedliche Algorithmen, die alle auf der Basis von exakt dieselben Ergebnisse liefern :NNNNN

1: Chris Hardwicks Formel:

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

Probieren Sie es auf WolframAlpha.

2: Christopher Mowlas Trigger Formel:

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

Probieren Sie es auf WolframAlpha.

3: Christopher Mowlas Primzahlen Formel:

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)

wo ist .96577(13×17×19×23)

Probieren Sie es auf WolframAlpha.

Quelle: Cubers-reddit - Mathematische Zählformeln für die Anzahl der Positionen, die Anzahl Gottes usw.

Herausforderung:

Wählen und implementieren Sie eine dieser drei Formeln (oder Ihre eigene Ableitung), die bei einer Eingabe-Ganzzahl im Bereich das richtige Ergebnis liefert.N[2,100]

Herausforderungsregeln:

  • Es steht Ihnen frei, eine andere Formel als diese drei zu verwenden. Beachten Sie jedoch, dass diese drei nachweislich korrekt sind. Wenn Sie eine andere Formel verwenden, fügen Sie bitte einen Link hinzu, über den Sie die Formel erhalten haben (oder wenn Sie selbst darauf gekommen sind, fügen Sie eine ausführliche Erläuterung hinzu). Und ich werde nach allen ganzen Zahlen im Bereich suchen, ob die Ausgabe korrekt ist. Vielleicht könnte Inspiration in der Oeis für diese Sequenz gefunden werden: A075152 .
  • Wenn Ihre Sprache automatisch eine wissenschaftliche Ausgabe ausgibt (dh anstelle der Zahl nach der 4x4x4-Formel), ist dies zulässig. Fügen Sie Ihrer Antwort jedoch zusätzlichen Code hinzu, um diese wissenschaftliche Rundung in eine exakte Ausgabe umzuwandeln, damit die Ergebnisse überprüft werden können, da Rundungsfehler aufgrund der Gleitkommapräzision während der Ausführung der Formel in Ihrem Code nicht zulässig sind - das tatsächliche Ergebnis sollte es sein genau.1,401 ...×1045
  • Ihr Programm / Ihre Funktion sollte für mindestens die Eingaben im Bereich korrekt sein (obwohl, da bereits eine Riesen-Arsch-Zahl ergibt, wird jedes größere wahrscheinlich auch funktionieren, wenn Sie dies ausgeben können eine richtig).[2,100]N=100N
  • Sie dürfen nicht alle möglichen Permutationen mit einem Zähler durchlaufen, da dies in einem angemessenen Zeitraum zu keiner Ausgabe führen würde. Nur die Implementierung einer Formel (entweder eine der drei bereitgestellten, eine Ableitung einer dieser Formeln oder eine völlig neue Formel) oder eine andere Methode, die in angemessener Zeit die richtigen Ergebnisse liefert (natürlich ohne harte Kodierung) ) ist erlaubt. Ich habe darüber nachgedacht, eine hinzuzufügen , um dies durchzusetzen, aber ich persönlich bin gegen eine in Kombination mit , also werde ich das nicht tun. Vergewissern Sie sich dennoch, dass Ihr Programm die Antworten gibt. Wenn es aus irgendeinem Grund für TIO zu langsam ist, fügen Sie zur Überprüfung einige Screenshots mit der Ausgabe von Ihrem lokalen Computer hinzu.

Allgemeine Regeln:

  • Das ist , also gewinnt die kürzeste Antwort in Bytes.
    Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
  • Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
  • Standardlücken sind verboten.
  • Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
  • Außerdem wird dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle:

Hier die Testfälle für im Bereich (für größere Testfälle können Sie die obigen WolframAlpha-Links verwenden):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

ANMERKUNG: Da dies eine Herausforderung ist, läuft es im Wesentlichen darauf hinaus, eine dieser drei Formeln (oder eine Ableitung / Ihre eigene Methode, die immer noch die richtigen Ergebnisse liefert) so kurz wie möglich zu implementieren.


2
Dies in x86-64 zu tun, wird eine lustige Herausforderung sein. Ich muss meine eigene Bigint rollen (wahrscheinlich nur ein 256-Bit- oder 512-Bit-Int) und es golf machen.
Moonheart08


4
Beachten Sie, dass Mowlas "Trigger" -Formel nur und cos 2 verwendet , um s zu verschleiern . Sünde2cos2floor
Attinat

4
@attinat, ich denke, es ist eine nützlichere Perspektive zu sagen, dass sowohl der Trigger als auch die Böden verschleiernNmod2
Peter Taylor

2
@ChristopherMowla Nimm ihre Kommentare nicht persönlich. Ich bin erstaunt, dass Sie diese Formeln gefunden und so genaue Vorhersagen getroffen haben, und Ihre Formeln waren eine der Inspirationen für diese Herausforderung. Dies ist jedoch Code-Golf. Daher werden Lesbarkeit, Leistung, Warnungen, Best Practices, historische Bedeutung und manchmal auch der gesunde Menschenverstand über Bord geworfen, wenn ein einzelnes Byte in einer Antwort gespeichert werden kann. ;) attinat und peter taylor schlugen einfach einen solchen golf anhand ihrer formeln vor, da n mod 2 in programmiersprachen deutlich kürzer zu verwenden ist als trig.
Kevin Cruijssen

Antworten:


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

Probieren Sie es online!

verwendet Herbert Kociembas Algorithmus, der auf der OEIS-Seite zu finden ist

Hier ist die rekursive Formel:
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 von @Peter Taylor gespeichert

Ein weiteres Byte, das von @Expired Data gespeichert wurde



@ExpiredData sehr schön! Ich habe versucht, dasselbe zu tun, aber es ist fehlgeschlagen, weil die Reihenfolge anders war
J42161217

Die Frage erfordert keine Unterstützung f@1, daher können Sie 6 Bytes sparen. Natürlich möchten Sie auch Ihr Testframework für die Verwendung anpassen Range[2,10].
Peter Taylor

@PeterTaylor tolle Beobachtung. Vielen Dank!
J42161217

@CSM muss leider f [3] definiert werden. Andernfalls gibt die Formel falsche Ergebnisse zurück
J42161217

9

x86-Maschinencode, 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

Die Funktion nimmt die Anzahl nin ecx, und einen Zeiger auf eine Zeichenkette auf Aufhellblitz edx(dh fastcallconvention).

Bevor ich den Quellcode zeige, einige Erklärungen, wie es die Sache macht. Es wird die rekursive Formel verwendet, die ich folgendermaßen geschrieben habe:

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

Alles, was der Code tun sollte, ist die Multiplikation mit kleinen Zahlen. Die Zahlen liegen im Bereich von 6 bis 36, was klein genug ist, um in einer 32-Bit-Bitmap dargestellt zu werden. Ich speichere eigentlich nicht das Bit, das die Multiplikation mit 6 darstellt - so kann ich den Code in einer do-whileSchleife anordnen , beginnend mit der bedingungslosen Multiplikation mit 6.

Die großen Zahlen werden in Dezimalform dargestellt - jedes Byte ist ein Wert im Bereich von 0 bis 9, beginnend mit dem MSB.

Die Multiplikation wird von LSB zu MSB durchgeführt; Es wird davon ausgegangen, dass die Anzahl der Stellen bei jeder Multiplikation um 2 zunimmt. Nach der Multiplikation mit einem kleinen Faktor wie 6 wächst die Anzahl der Stellen möglicherweise nur um 1. Wenn also MSB = 0 ist, wird das gesamte Zwischenergebnis nach links verschoben. Es kann tatsächlich vorkommen, dass die Anzahl der Stellen überhaupt nicht wächst und das MSB dann immer noch 0 ist. Dieses Problem wird jedoch behoben, wenn der Code mit größeren Faktoren fortfährt.

Da der Multiplikationscode groß ist, möchte ich ihn nicht zweimal ausdrücken. Ich möchte es auch nicht in eine Funktion verschieben, da der Maschinencode zum Aufrufen einer Funktion groß ist. Also habe ich die äußeren Schleifen so umgestellt, dass der Multiplikationscode nur einmal benötigt wird.

C-Code:

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

Demontage:

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;

Die Laufzeit für n = 100 beträgt ungefähr 4 Sekunden und das Ergebnis ist eine Zahl mit 38416 Ziffern:

23491019577617 (viele Ziffern hier) ... (viele Nullen hier) 0000000000000000


8

05AB1E , 38 Bytes

Erster Versuch.
Verwendet Chris Hardwicks Formel .
Werde versuchen weiter zu golfen und erklären wann ich Zeit habe.

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

Probieren Sie es online!


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)

Probieren Sie es online!

Verwendet Chris Hardwicks Formel. Übernimmt die Eingabe als Big Integer.

Vielen Dank an H.PWiz für -7 Bytes


1
~=n->factorial(big(n))-> ~n=prod(big,1:n)und (24576*~12)^(n%2)->^(24576*~12,n%2)
H.PWiz

Warum benutzt du ~=n->statt ~n=?
H.PWiz

@ H.PWiz, einfach, weil ich nicht einmal wusste, dass es so funktionieren würde, und auch nicht bemerkt, dass in Ihrem vorherigen Kommentar :)
Kirill L.




6

JavaScript (Node.js) , 77 75 73 Byte

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

Probieren Sie es online! Basierend auf Christopher Mowlas Formel. Nimmt ein BigInt als Eingabe. Testgeschirr schamlos von @Arnauld gestohlen. 0xb88d4641131f0nist 3246670537110000nin Dezimalzahl. Erläuterung: Ich habe mit dem letzten Prim-Exponenten begonnen und ihn auf vereinfacht n*(n-2n)/4n(dies ist eine Ganzzahldivision, daher brauche ich keine Anpassung für ungerade Zahlen). Ich untersuchte dann die anderen Primzahlen, um festzustellen, ob ihre Exponenten mit diesem Wert in Beziehung standen (den ich als bezeichnen werde o), und stellte fest, dass sie auf eine Art und Weise waren, wenn ich die Verwendung der Parität von n(den ich als bezeichnen werde) erlaubte p). Die Formeln für die Exponenten lauten wie folgt:

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

Die Potenzen können dann nach Exponenten gruppiert werden, beispielsweise pist dies der Exponent von 11*7*5**2*3**3*2**14.


5

Schläger , 151 141 Bytes

-7 bytes dank 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))))

Probieren Sie es online!

Die längste Antwort mit Chris Hardwicks Formel :)


1
Sie könnten die für eine λ definieren ändern (2 Bytes) und einen Standardwert für einen zusätzlichen Parameter verwenden 3 weitere Bytes aus den drei speichern exptAnrufen: (λ(n[e expt])...(e ...)...).
fede s.

@fedes. Vielen Dank!
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)

Probieren Sie es online!

Verwendet die rekursive Methode von Herbert Kociemba.

-2 Bytes dank Herman L


2 Bytes können durch Ersetzen 3**6durch 729 und 2**10durch 1024 TIO
Herman L

Hey, schöner Fang!
GotCubes

Die Definition Ihrer eigenen Fakultätsfunktion ist 3 Bytes kürzer
ovs

103 Bytes mit fest codierten Fakultätswerten
ovs


3

CJam (47 Bytes)

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

Online-Demo

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




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

Probieren Sie es online!


1
Schlagen Sie N--*--N/4statt (N*N-2*N)/4und entfernen Sie N-=2und#define s mpz_init_set_str
Ceilingcat




1

Schale , 51 48 44 Bytes

-4 Bytes dank H.PWiz

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

Probieren Sie es online!

Dies ist die Formel von Chris Hardwick. Dies ist auch mein erstes Schalenprogramm, daher wären alle Tipps sehr willkommen.


1
Hier ist eine einfache 2 Bytes:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz

1
Oder, noch besser,÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz

1

Bildbeschreibung hier eingeben

C ++, 187 185 180 176 195 (es gab einen Fehler) 193 175 Bytes (mit Hilfe von Ceiling Cat)

Hierfür werden der GMP C ++ - Wrapper (GNU Multi-Precision Library) und die von @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ) verwendete Formel verwendet .

Verwenden Sie g++ -g rubix.cpp -lgmp -lgmpxxzum Kompilieren und Link

#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, mit testcode

#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/


Könnten Sie vielleicht einen Screenshot des n=10Testfalls hinzufügen , damit ich überprüfen kann, ob er funktioniert? Ich vermute, es gibt keine Möglichkeit, diese Arbeit auf dem C ++ (Clang) oder C ++ (GCC) TIO aufgrund der verwendeten Bibliothek zu machen?
Kevin Cruijssen

argg. Es funktioniert nicht für ungerade Werte von n
CSM

1
Vielen Dank für den Screenshot und gut, dass Sie den Fehler lokalisieren und beheben konnten. +1 von mir. :)
Kevin Cruijssen


Ta @ceilingcat. Die #define-Rückgabe wird nicht mehr benötigt, da es nur zwei Rückgabepunkte gibt
CSM

1

TI-BASIC, 63 62 Bytes (nicht konkurrierend)

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

Ausdruck, der die Eingabe als Ganzzahl annimmt Ans. Implementierung der Chris Hardwick Formel. Nicht konkurrierend, da die Hardware, auf der es ausgeführt wird, nur bis zu 16 Dezimalstellen speichert, sodass die Antwort niemals 100% genau ist.

Erläuterung:

{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
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.