NxNxNルービックキューブの順列の量


35

前書き:

3x3x3ルービックキューブが有する43,252,003,274,489,856,000は約43である、可能な順列を。この数値については聞いたことがあるかもしれませんが、実際にはどのように計算されますか?

3x3x3ルービックキューブには6つの側面があり、それぞれに9つのステッカーがあります。ただし、ステッカーではなく(外部)ピースを見ると、6つの中央ピースがあります。8つの角の部分。12個のエッジピース。センターは移動できないため、計算ではそれらを無視できます。コーナーとエッジに関して:

  • 8!あります40,320)の方法は、8つのコーナーを配置します。各コーナーには3つの方向がありますが、独立して方向付けできるのは7つ(8つのうち)だけです。第八/最終コーナーの向きは、所与の、先行7に依存372,187)の可能性。
  • 12個あります12!2239,500,80012面の縁部を配置する)方法。12!から半分にこれは、角が正確に一致するときに、エッジが常に偶数の順列にある必要があるためです。イレブンエッジが所定の第12 /最終的なエッジのフリップフロッ先行11に依存して、独立して反転することができる2112,048)の可能性。

これをまとめると、次の式があります。

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

出典:Wikipedia-ルービックキューブ順列

これはすでにかなり複雑に見えるかもしれませんが、3x3x3キューブの場合はまだかなり単純です。偶数キューブの場合、式はわずかに異なります。これは、たとえば4x4x4キューブの式です。

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

これは、短いスケールで約7.40 quattuordecillionです。

また、より大きなNxNxNキューブ(つまり、現在の世界記録33x33x33)の場合、式はかなり拡張されます。ただし、この紹介を長くしすぎないように、代わりにこれらのリンクをここに配置します。ここでは、4x4x4キューブと他のサイズのNxNxNキューブの順列を結果の式で説明します。

あなたは今疑問に思っているかもしれません:に基づいた一般的な公式はありますか Nの任意のためのN xはN xはNキューブ?確かにあります。N基づいてまったく同じ結果を与える3つの完全に異なるアルゴリズムを次に示します。

1:クリスハードウィックのフォーミュラ:

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

WolframAlphaで試してみてください。

2:クリストファー・モウラの三角式:

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

WolframAlphaで試してみてください。

3:クリストファー・モウラの素数式:

212×(2×N×(N+7)1711×(1)N)×3N×(N+1)+2×512×(2×N×(N2)+1+(1)N)×718×(6×N×(N2)+3+5×(1)N)×1114×(2×N×(N2)1+(1)N)×9657718×(2×N×(N2)3+3×(1)N)

ここで、96577(13×17×19×23)です。

WolframAlphaで試してみてください。

出典:Cubers-reddit-位置の数、神の数などの数学的計算式

チャレンジ:

入力整数与えられており、これら三つの式(または独自の誘導体)のいずれかを選択し、実装Nレンジでの[2,100]、正しい結果を出力します。

チャレンジルール:

  • これら3つ以外の別の式を自由に使用できますが、これら3つが正しいことが証明されていることに注意してください。別の式を使用する場合は、元の式のリンクを追加してください(または、自分で計算する場合は、詳細な説明を追加してください)。そして、出力が正しい場合、範囲内のすべての整数をチェックします。おそらくインスピレーションは、このシーケンスA075152のoeisにあります。
  • あなたの言語が科学的な出力を自動的に出力する場合(すなわち、4x4x4式の後の数字の代わりに1.401 ...×1045)、これは許可されます。ただし、コード内の式の実行中の浮動小数点精度による丸め誤差は許可されないため、この科学的な丸めを正確な出力に変換して、結果を検証できるように追加のコードを回答に追加してください-実際の結果は正確。
  • プログラム/機能は、範囲内の少なくとも入力の正しいあるべきである[2100](以降、ただしN=100既に任意大きく、巨大なお尻の数になりますNおそらく仕事だけでなく、あなたしていることにした場合でしょうこれを正しく出力してください)。
  • カウンターを使用してすべての可能な順列をループすることはできません。合理的な時間内に何も出力されないためです。フォーミュラ(提供されている3つのうちの1つ、それらの1つの派生物、または完全に新しいフォーミュラ)の実装、または妥当な時間内に正しい結果を与える別のメソッド(もちろんハードコーディングなし) ) 許可されている。これを強制するためにを追加することを考えましたが、私は個人的に反対ですとの組み合わせにので、私はしません。それでも、プログラムが答えを出していることを確認してください。何らかの理由でTIOにとって遅すぎる場合は、検証としてローカルマシンからの出力を含むスクリーンショットを追加してください。

一般的なルール:

  • これはであるため、バイト単位の最短回答が優先されます。
    コードゴルフ言語では、コードゴルフ以外の言語で回答を投稿しないようにしてください。「任意の」プログラミング言語の可能な限り短い答えを考えてみてください。
  • デフォルトのI / Oルールを使用した回答には標準ルールが適用されるため、STDIN / STDOUT、関数/メソッド、適切なパラメーターおよび戻り値型、完全なプログラムを使用できます。あなたの電話。
  • デフォルトの抜け穴は禁止されています。
  • 可能であれば、コードのテストへのリンク(TIOなど)を追加してください。
  • また、回答の説明を追加することを強くお勧めします。

テストケース:

ここでのテストケースNレンジでは[210](より大きなテストケースのための上記WolframAlphaリンクを使用して自由に感じます)。

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

注:これは課題なので、基本的には次のように要約します。これら3つの式のいずれか(または、正しい結果を生成する導関数/独自のメソッド)をできるだけ短く実装します。


2
x86-64でこれを行うのは楽しいチャレンジです。私は自分のbigint(おそらくちょうど256ビットまたは512ビットのint)を転がして、ゴルフをしなければなりません。
moonheart08


4
Mowlaの "trig"式は、cos 2を使用してs を難読化するだけであることに注意してください。2cos2floor
attinat

4
@attinat、トリガーとフロアの両方が難読化していると言ったほうが便利だと思いますNmod2
Peter Taylor

2
@ChristopherMowlaコメントを個人的に受け取らないでください。そもそもこれらの式を見つけて、そのような正確な予測をすることができたことに驚いています。あなたの式はこの挑戦のインスピレーションの一つでした。ただし、これはコードゴルフであるため、回答の1バイトを節約できる場合は、読みやすさ、パフォーマンス、警告、ベストプラクティス、歴史的重要性、および常識がすべて捨てられます。;)attinatPeterTaylorは、N mod 2がプログラミング言語で使用するのにtrigよりもかなり短いので、単にあなたの式に基づいてそのようなゴルフを提案しました。
ケビンクルーッセン

回答:


12

Wolfram言語(Mathematica)、59バイト

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

オンラインでお試しください!

OEISページにある Herbert Kociembaのアルゴリズムを使用

再帰式は次のとおりです。
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)

@Peter Taylorによって6バイト節約

@Expired Dataによって保存されたもう1バイト



@ExpiredDataとても素敵です!私は同じことをしようとしていたが、順番が違っていた原因、それに失敗しました
J42161217

質問ではをサポートする必要はないためf@1、6バイト節約できます。使用するテストフレームワークも調整する必要があることは明らかですRange[2,10]
ピーターテイラー

@PeterTaylor素晴らしい観察。ありがとう!
J42161217

@CSMは不幸にもf [3]を定義する必要があります。そうでない場合、式は間違った結果を返します
J42161217

9

x86マシンコード、119バイト

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

関数は番号を受け取ります necx、する文字列へのポインターをますedx(つまり、fastcall慣例)ます。

ソースコードを表示する前に、それがどのように機能するかについて説明します。次のように書いた再帰式を使用します。

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

そのため、コードで実行する必要があるのは、小さな数値を乗算することだけです。数値は6〜36の範囲で、32ビットのビットマップで表すには十分小さいです。私は実際に6による乗算を表すビットを保存しません-これにより、コードをdo-while、6による無条件の乗算から始めてループに。

大きな数字は10進数形式で表されます-各バイトは、MSBから始まる0 ... 9の範囲の値です。

乗算はLSBからMSBへ実行されます。乗算ごとに桁数が2ずつ増えると想定しています。6のような小さな係数で乗算を行った後、桁数は1だけ増加する可能性があります。したがって、MSB = 0の場合、中間結果全体が左に移動します。実際には、桁数がまったく増加せず、MSBが0のままになることがありますが、コードがより大きな要因に進むにつれて、この問題は解決します。

乗算コードは大きいため、2回配置したくありません。関数を呼び出すためのマシンコードが大きいため、関数に移動する必要もありません。そこで、乗算コードが1回だけ必要になるように、外側のループを再配置しました。

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

分解:

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;

n = 100の実行時間は約4秒で、結果は38416桁の数値です。

23491019577617(ここに多くの数字)...(ここに多くのゼロ)0000000000000000



8

ジュリア1.083の、76バイト

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

オンラインでお試しください!

クリス・ハードウィックのフォーミュラを使用しています。入力をビッグ整数として受け取ります。

-7バイトのH.PWizに感謝


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

なぜ~=n->代わりに使用するの~n=ですか?
H.PWiz

@ H.PWiz、単純にそれがこのように機能することさえ知らなかったからであり、あなたの以前のコメントでもそれに気づかなかったからです:)
キリルL.



6

JavaScript(Node.js)、81バイト

ハーバートコシエンバの再帰式。入力としてBigIntを受け取ります。

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

オンラインでお試しください!


JavaScript(Node.js) 102 98  96バイト

クリス・ハードウィックの式。入力としてBigIntを受け取ります。

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

オンラインでお試しください!


6

JavaScript(Node.js)77 75 73バイト

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

オンラインでお試しください!クリストファー・モウラの式に基づいています。入力としてBigIntを受け取ります。@Arnauldから恥知らずに盗まれたテストハーネス。0xb88d4641131f0nある3246670537110000n小数で。説明:最後の素数指数から始めて、それを単純化しましたn*(n-2n)/4n(これは整数除算なので、奇数の調整は必要ありません)。次に、他の素数を調べて、それらの指数がこの値に関連しているかどうかを確認し(これをとして参照しますo)、パリティの使用を許可した場合、それらがファッションの後であることを発見しましたn(これをp)。指数の式は次のとおりです。

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

べき乗は指数でグループ化できるので、たとえばpの指数は11*7*5**2*3**3*2**14です。


5

ラケット151 141バイト

fedeのおかげで-7バイト!

(λ(n[e expt])(/(*(e 11771943321600(modulo n 2))3674160(e 620448401733239439360000(floor(/(*(- n 2)n)4))))(e 24(*(floor(/(sqr(- n 2))4))6))))

オンラインでお試しください!

クリス・ハードウィックのフォーミュラを使用した最長の回答:)


1
λ(2バイト)の定義を変更し、追加のパラメーターにデフォルト値を使用して、3つのexpt呼び出しからさらに3バイトを節約できます(λ(n[e expt])...(e ...)...)
フェデ

@fedes。ありがとう!
ガレンイワノフ

4

Python 2、122バイト

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)

オンラインでお試しください!

Herbert Kociemba再帰メソッドを使用します。

ハーマンLのおかげで-2バイト


2つのバイトが交換することによって保存することができる3**6729とと2**101024 TIO
ハーマンL

ねえ、いいキャッチ!
GotCubes

独自の階乗関数の定義は3バイト短くなります
ovs

ハードコーディングされた階乗値を含む103バイト
ovs


3

CJam(47バイト)

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

オンラインデモ

これにより、OEISからのハーバートコシエンバの再帰が実装されます。

an={1 もし n{01}7×36 もし n=2an1×3×12×213 もし n=3an2×24246n2×246 もし n>3
CJamのメモされた再帰演算子を使用しjます。CJamを読んでいる人に対応を確認しやすくするために、MathJaxブロックの用語をコードと同じ順序で注文しました。これ以上の分析はこれ以上明らかにならないでしょう。




2

C(gcc) -lgmp、279バイト

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

オンラインでお試しください!


1
提案するN--*--N/4代わりに(N*N-2*N)/4して削除N-=2して#define s mpz_init_set_str
ceilingcat




1

ハスク51 48 44バイト

H.PWizのおかげで-4バイト

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

オンラインでお試しください!

これがクリス・ハードウィックのフォーミュラです。また、これは私の最初の殻プログラムですので、どんなヒントでも大歓迎です。


1
ここでは簡単に2バイトです:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz

1
または、より良い、÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz

1

ここに画像の説明を入力してください

C ++、187185180176195(バグがありました)193175バイト(天井猫の助けを借りて)

これは、GMP C ++ラッパー(GNU多精度ライブラリ)と@ J42161217(https://codegolf.stackexchange.com/a/183381/55953)が使用する式を使用します

g++ -g rubix.cpp -lgmp -lgmpxxコンパイルとリンクに使用

#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、テストコード付き

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


おそらくn=10テストケースのスクリーンショットを追加してください。そうすれば、動作することを確認できますか?ライブラリを使用しているため、この作業をC ++(clang)またはC ++(gcc)TIOで実行する方法はないのでしょうか。
ケビンクルーッセン

argg。nの奇数の値に対しては機能しません
CSM

1
スクリーンショットをお寄せいただきありがとうございます。エラーを特定して修正できたことに感謝します。私から+1。:)
ケビンクルーイッセン


Ta @ceilingcat。2つだけのリターンポイントがありますように#defineリターンは、もはや必要とされていません
CSM

1

TI-BASIC、63 62 バイト、(非競合)

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

入力を整数として受け取る式 Ans。クリスハードウィックの式の実装。競合するハードウェアは小数点以下16桁までしか保存されないため、競合しません。そのため、答えは100%正確ではありません。

説明:

{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
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.