एक NxNxN रूबिक क्यूब पर क्रमपरिवर्तन की राशि

Question

परिचय:

एक 3x3x3 रूबिक के क्यूब में संभावित क्रमांकन हैं, जो लगभग 43 क्विंटल है । आपने पहले इस संख्या के बारे में सुना होगा, लेकिन वास्तव में इसकी गणना कैसे की जाती है?$43,252,003,274,489,856,000$

एक 3x3x3 रूबिक के क्यूब में छह पक्ष हैं, प्रत्येक में नौ स्टिकर हैं। स्टिकर के बजाय (बाहरी) टुकड़ों को देखते हुए, हमारे पास छह केंद्र टुकड़े हैं; आठ कोनों के टुकड़े; और बारह किनारे टुकड़े। चूंकि केंद्रों को स्थानांतरित नहीं किया जा सकता है, इसलिए हम गणना में उन्हें अनदेखा कर सकते हैं। कोनों और किनारों के लिए:

• कर रहे हैं( ) आठ कोनों को व्यवस्थित करने के तरीके। प्रत्येक कोने में तीन संभव अभिविन्यास हैं, हालांकि केवल सात (आठ में से) स्वतंत्र रूप से उन्मुख हो सकते हैं; आठवें / अंतिम कोने का उन्मुखीकरण पूर्ववर्ती सात पर निर्भर करता है, ( ) संभावनाएं दी गई हैं।$8!$$40,320$$3^7$$2,187$
• कर रहे हैं ( ) तरीके बारह किनारों की व्यवस्था करने की। से आधा हो गयाऐसा इसलिए है क्योंकि किनारों को हमेशा एक समान क्रम में होना चाहिए जब कोने हों। ग्यारह किनारों को स्वतंत्र रूप से फ़्लिप किया जा सकता है, पूर्ववर्ती ग्यारह के आधार पर बारहवें / अंतिम छोर के फ्लिप के साथ, ( ) संभावनाएं दी गई हैं।$\frac{12!}{2}$$239,500,800$!००$12!$$2^{11}$$2,048$

इसे एक साथ रखकर, हमारे पास निम्नलिखित सूत्र हैं:

$$8!×3^7×\frac{12!}{2}×2^{11} = 43,252,003,274,489,856,000$$

^{स्रोत: विकिपीडिया - रूबिक के घन क्रमपरिवर्तन}

हालांकि यह पहले से ही बहुत जटिल लग सकता है, यह अभी भी एक 3x3x3 क्यूब के लिए सीधे-आगे है। यहां तक ​​कि क्यूब्स के लिए सूत्र थोड़ा अलग है; यह उदाहरण के लिए 4x4x4 घन के लिए सूत्र है:

$$\frac{8!×3^7×24!^2}{24^7} = 7,401,196,841,564,901,869,874,093,974,498,574,336,000,000,000$$

जो कि छोटे पैमाने पर लगभग 7.40 क्वैटुआर्डेसिलिन है ।

और बड़े NxNxN क्यूब्स के लिए (यानी वर्तमान विश्व रिकॉर्ड 33x33x33) सूत्र को थोड़ा बढ़ाया जाएगा। इस परिचय को बहुत लंबा नहीं बनाने के लिए, मैंने इन कड़ियों को यहां रखा, जहां 4x4x4 क्यूब और कुछ अन्य आकार के NxNxN क्यूब्स के क्रमपरिवर्तन को एक परिणामी सूत्र के साथ समझाया गया है:

• 2x2x2
• 4x4x4
• 5x5x5
• 6x6x6
• 7x7x7
• 33x33x33

आप अब तक सोच रहे होंगे: क्या किसी एक्स एक्स क्यूब के लिए पर आधारित एक सामान्य सूत्र है ? वहाँ निश्चित रूप से है। यहां तीन पूरी तरह से अलग एल्गोरिदम हैं, सभी आधार पर सटीक समान परिणाम दे रहे हैं :$N$$N$$N$$N$$N$

1: क्रिस हार्डविक का फॉर्मूला:

$$\frac{(24×2^{10}×12!)^{N\pmod2}×(7!×3^6)×(24!)^{\lfloor{\frac{1}{4}×(N^2-2×N)}\rfloor}}{(4!)^{6×\lfloor{\frac{1}{4}×(N-2)^2}\rfloor}}$$

इसे वुल्फरामअल्फा पर आज़माएं।

2: क्रिस्टोफर मोवला का ट्रिगर फॉर्मूला:

$$8!×3^7×\left(\frac{24!}{(4!)^6}\right)^{\frac{1}{4}×((N-1)×(N-3)+\cos^2(\frac{N×\pi}{2}))}×(24!)^{\frac{1}{2}×(N-2-\sin^2(\frac{N×\pi}{2}))}×(12!×2^{10})^{\sin^2(\frac{N×\pi}{2})}×\frac{1}{24^{\cos^2(\frac{N×\pi}{2})}}$$

इसे वुल्फरामअल्फा पर आज़माएं।

3: क्रिस्टोफर मोवला के सूत्र फॉर्मूला:

$$2^{\frac{1}{2}×(2×N×(N+7)-17-11×(-1)^N)}×3^{N×(N+1)+2}×5^{\frac{1}{2}×(2×N×(N-2)+1+(-1)^N)}×7^{\frac{1}{8}×(6×N×(N-2)+3+5×(-1)^N)}×11^{\frac{1}{4}×(2×N×(N-2)-1+(-1)^N)}×96577^{\frac{1}{8}×(2×N×(N-2)-3+3×(-1)^N)}$$

जहां है ।$96577$$(13×17×19×23)$

इसे वुल्फरामअल्फा पर आज़माएं।

^{स्रोत: क्यूबर्स-रेडिट - गणितीय गणना, पदों की संख्या, भगवान की संख्या, आदि।}

चुनौती:

इन तीन सूत्रों (या अपने स्वयं के व्युत्पन्न) में से एक को चुनें और कार्यान्वित करें, जिसने सीमा में एक इनपुट-पूर्णांक दिया , सही परिणाम का उत्पादन करता है।$N$$[2,100]$

चुनौती नियम:

• आप इन तीनों के अलावा किसी अन्य सूत्र का उपयोग करने के लिए स्वतंत्र हैं, लेकिन ध्यान रखें कि ये तीनों सही साबित होते हैं। यदि आप किसी अन्य सूत्र का उपयोग करते हैं, तो कृपया एक लिंक जोड़ें जहां से आपको यह मिला है (या यदि आप इसके साथ आते हैं तो अपने आप में एक गहराई से स्पष्टीकरण जोड़ते हैं)। और मैं रेंज में सभी पूर्णांकों के लिए जाँच करूँगा कि क्या आउटपुट सही है। शायद इस अनुक्रम के लिए ओईस में प्रेरणा पाई जा सकती है : A075152 ।
• यदि आपकी भाषा स्वचालित रूप से एक वैज्ञानिक आउटपुट (यानी 4x4x4 सूत्र के बाद की संख्या के बजाय) का उत्पादन करती है तो इसकी अनुमति है। लेकिन कृपया इस वैज्ञानिक गोलाई को एक सटीक आउटपुट में बदलने के लिए अपने उत्तर में अतिरिक्त कोड जोड़ें ताकि परिणामों को सत्यापित किया जा सके, क्योंकि आपके कोड में सूत्र के निष्पादन के दौरान फ़्लोटिंग पॉइंट परिशुद्धता के कारण त्रुटियों को गोल करने की अनुमति नहीं है - वास्तविक परिणाम होना चाहिए सटीक।$1.401...×10^{45}$
• आपका प्रोग्राम / फ़ंक्शन कम से कम इनपुट के लिए सीमा में सही होना चाहिए (हालांकि, बाद से पहले से ही एक विशाल-गधा संख्या में परिणाम होता है, कोई भी बड़ा संभवतः काम करेगा और यदि आप इसे आउटपुट करने में सक्षम हैं एक सही ढंग से)।$[2,100]$$N=100$$N$
• आपको एक काउंटर के साथ सभी संभावित क्रमपरिवर्तन करने की अनुमति नहीं है, क्योंकि यह समय की उचित मात्रा में कुछ भी उत्पादन नहीं करेगा। केवल एक सूत्र का कार्यान्वयन (तीन में से एक प्रदान किया गया, उनमें से एक का व्युत्पन्न, या एक पूरी तरह से नया सूत्र), या एक अन्य विधि जो उचित परिणाम समय के बिना (कठिन-कोडिंग के बिना) सही परिणाम देगा ) की अनुमति है। मैंने इसे लागू करने के लिए एक प्रतिबंधित-समय को जोड़ने के बारे में सोचा , लेकिन मैं व्यक्तिगत रूप से कोड-गोल्फ के साथ संयोजन में प्रतिबंधित-समय के खिलाफ हूं , इसलिए मैं नहीं करूंगा। फिर भी, कृपया सुनिश्चित करें कि आपका कार्यक्रम उत्तर देता है, और यदि यह किसी कारण से TIO के लिए बहुत धीमा है, तो सत्यापन के रूप में अपने स्थानीय मशीन से आउटपुट के साथ कुछ स्क्रीनशॉट जोड़ें।

सामान्य नियम:

• यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
  कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
• डिफ़ॉल्ट I / O नियमों के साथ आपके उत्तर के लिए मानक नियम लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-प्रकार, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा कॉल।
• डिफ़ॉल्ट ढीले निषिद्ध हैं।
• यदि संभव हो, तो कृपया अपने कोड (यानी TIO ) के लिए एक परीक्षण के साथ एक लिंक जोड़ें ।
• साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।

परीक्षण के मामलों:

यहाँ में परीक्षण के मामले (बड़े मामलों के लिए ऊपर दिए गए वुल्फरामाल्फा लिंक का उपयोग करने के लिए स्वतंत्र महसूस करें):$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

नोट: चूंकि यह एक कोड-गोल्फ चुनौती है, इसलिए यह मूल रूप से उबलता है: इन तीन सूत्रों में से एक को लागू करें (या एक व्युत्पन्न / आपकी खुद की विधि जो अभी भी सही परिणाम पैदा करती है) जितना संभव हो उतना कम।

Comments

X86-64 में ऐसा करना एक मजेदार चुनौती होगी। मुझे अपना खुद का बिगिंट रोल करना होगा (संभवतः सिर्फ 256-बिट या 512-बिट इंट), और इसे गोल्फ बनाऊंगा।

— चन्द्रावत ०

@ moonheart08 ध्यान दें कि N = 100 के साथ, परिणाम लगभग 128 Kb (16 KB) होता है: https://www.wolframalpha.com/input/?i=for+n+%3D+100,+N%5BLog_5B2, + ((24 * 2% 5E10 * 12)% 5EMod% 5bn, + 2% 5D + 7 3% 5E6 + 24% 5EFloor% 5 ब (एन% 5E2 + -! + 2 + एन)% 2F4% 5D)% 2F4!% 5E (6 + फ्लोर% 5B (n + - + 2)% 5E2% 2F4% 5D)% 5D, 3% 5D

— सोलोमन उको

ध्यान दें कि मोवला के "ट्रिग" फॉर्मूले में सिर्फ और करना है । कोस $\sin^2$$\cos^2$floor

— attinat

@attinat, मुझे लगता है कि यह कहना अधिक उपयोगी है कि और फर्श दोनों कर रहे हैं$N \bmod 2$

— पीटर टेलर

@ChristopherMowla उनकी टिप्पणियों को व्यक्तिगत न लें। मुझे आश्चर्य है कि आप इन फ़ार्मुलों को खोजने में सक्षम थे और पहली बार में इस तरह की सटीक भविष्यवाणियाँ की थीं, और आपके सूत्र इस चुनौती के लिए प्रेरणा थे। हालांकि यह कोड-गोल्फ है, इसलिए पठनीयता, प्रदर्शन, चेतावनियाँ, सर्वोत्तम अभ्यास, ऐतिहासिक महत्व और कभी-कभी सामान्य ज्ञान सभी को फेंक दिया जाता है अगर यह एक उत्तर पर एक बाइट बचा सकता है। ;) अटारीट और पीटरटायर ने अपने फॉर्मूले के आधार पर इस तरह के गोल्फ का सुझाव दिया, क्योंकि एन मोड 2 ट्रिगर की तुलना में प्रोग्रामिंग भाषाओं में उपयोग करने के लिए काफी कम है।

— केविन क्रूज़सेन

Answer 1

वोल्फ्राम भाषा (गणितज्ञ) , 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 पृष्ठ में पाए जाने वाले हर्बर्ट समाजेबा के एल्गोरिथ्म का उपयोग करता है

यहाँ पुनरावर्ती सूत्र है:
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 बाइट्स @Peter टेलर द्वारा सहेजे गए

@Expired Data द्वारा सेव किया गया एक और बाइट

Comments

65 बाइट्स

— समाप्त डेटा

@ExpiredData बहुत अच्छा! मैं भी ऐसा ही करने की कोशिश कर रहा था, लेकिन यह विफल रहा क्योंकि आदेश अलग था

— J42161217

प्रश्न का आपको समर्थन करने की आवश्यकता नहीं है f@1, इसलिए आप 6 बाइट्स बचा सकते हैं। जाहिर है आप भी उपयोग करने के लिए अपने परीक्षण ढांचे को समायोजित करना चाहते हैं Range[2,10]।

— पीटर टेलर

@PeterTaylor महान अवलोकन। धन्यवाद!

— J42161217

@CSM दुर्भाग्यपूर्ण रूप से f [3] को परिभाषित करने की आवश्यकता है। अन्यथा, सूत्र गलत परिणाम देता है

— J42161217

Answer 2

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

फ़ंक्शन (यानी कन्वेंशन) को भरने के लिए स्ट्रिंग nमें नंबर ecxऔर एक पॉइंटर को पॉइंटर प्राप्त करता है ।edxfastcall

इससे पहले कि मैं स्रोत कोड दिखाऊं, कुछ स्पष्टीकरण यह बताता है कि यह कैसे काम करता है। यह पुनरावर्ती सूत्र का उपयोग करता है, जिसे मैंने निम्नलिखित तरीके से लिखा था:

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 से बिना शर्त गुणा से होती है।

दशमलव संख्या का उपयोग करके बड़ी संख्याओं का प्रतिनिधित्व किया जाता है - प्रत्येक बाइट का मान 0 ... 9, MSB से शुरू होता है।

गुणन LSB से MSB तक किया जाता है; यह मानता है कि प्रत्येक गुणा के लिए अंकों की संख्या 2 से बढ़ेगी। 6 जैसे छोटे कारक द्वारा गुणा करने के बाद, अंकों की संख्या केवल 1 से बढ़ सकती है। इसलिए यदि MSB = 0, तो यह पूरे मध्यवर्ती परिणाम को छोड़ देता है। यह वास्तव में हो सकता है कि अंकों की संख्या बिल्कुल भी नहीं बढ़ती है, और फिर MSB अभी भी 0 होगा, लेकिन यह समस्या अपने आप ठीक हो जाएगी क्योंकि कोड अधिक से अधिक कारकों के लिए आगे बढ़ता है।

क्योंकि गुणा कोड बड़ा है, मैं इसे दो बार नहीं डालना चाहता। मैं इसे किसी फ़ंक्शन में नहीं ले जाना चाहता, क्योंकि किसी फ़ंक्शन को कॉल करने के लिए मशीन कोड बड़ा है। इसलिए मैंने बाहरी छोरों को इस तरह से पुनर्व्यवस्थित किया कि गुणा कोड केवल एक बार की आवश्यकता है।

सी कोड:

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

disassembly:

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

Answer 3

05AB1E , 38 बाइट्स

प्रारंभिक प्रयास। क्रिस हार्डविक के फॉर्मूला का
उपयोग करता है । आगे गोल्फ के लिए प्रयास करेंगे और बताएंगे कि मेरे पास कब समय है।

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

इसे ऑनलाइन आज़माएं!

Answer 4

जूलिया 1.0 , 83 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)

इसे ऑनलाइन आज़माएं!

क्रिस हार्डविक के फॉर्मूला का उपयोग करता है। बिग पूर्णांक के रूप में इनपुट लेता है।

H.PWiz -7 बाइट्स के लिए धन्यवाद

Comments

~=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, सिर्फ इसलिए कि मुझे नहीं पता था कि यह इस तरह से काम करेगा, और यह भी नहीं देखा कि आपकी पिछली टिप्पणी में :)

— Kirill L.

Answer 5

पायथन 2 , 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नीलn*(n-2)/4 से नकल करके 4 बाइट्स बचाए ।

Answer 6

वोल्फ्राम भाषा (गणितज्ञ) , 67 बाइट्स

क्रिस हार्डविक के फॉर्मूला का उपयोग करना।

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

इसे ऑनलाइन आज़माएं!

Comments

63 बाइट्स । के बारे में मेरा Mowla के "trig" सूत्र के आधार पर पोस्ट करने के लिए गया था, लेकिन यह पता चला इस के समान होना करने के लिए ...

— attinat

Answer 7

जावास्क्रिप्ट (Node.js) , 81 बाइट्स

हर्बर्ट समाजेमा का पुनरावर्ती सूत्र। इनपुट के रूप में एक BigInt लेता है।

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

इसे ऑनलाइन आज़माएं!

---

जावास्क्रिप्ट (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))

इसे ऑनलाइन आज़माएं!

Answer 8

जावास्क्रिप्ट (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।

Answer 9

रैकेट , 151 141 बाइट्स

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

इसे ऑनलाइन आज़माएं!

क्रिस हार्डविक के फॉर्मूला का उपयोग करने वाला सबसे लंबा जवाब :)

Comments

आप एक λ (2 बाइट्स) के लिए परिभाषित बदल सकते हैं, और एक अतिरिक्त पैरामीटर के लिए तीन exptकॉल से 3 बाइट्स को बचाने के लिए डिफ़ॉल्ट मान का उपयोग कर सकते हैं (λ(n[e expt])...(e ...)...):।

— फेड एस।

@fedes। धन्यवाद!

— गैलेन इवानोव

Answer 10

पायथन 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)

इसे ऑनलाइन आज़माएं!

हर्बर्ट समाजेमा पुनरावर्ती विधि का उपयोग करता है।

-2 बाइट्स हरमन एल को धन्यवाद

Comments

2 बाइट्स की जगह बचाया जा सकता है 3**6729 के साथ और 2**10साथ 1024 TIO

— हरमन एल

अरे, अच्छा पकड़!

— गोटक्यूब्स

अपने स्वयं के फैक्टरियल फ़ंक्शन को परिभाषित करना 3 बाइट्स छोटा है

— ओवर्स

— हार्डकॉटेड

Answer 11

जेली ,  39  38 बाइट्स

^{मुझे लगता है कि मैंने कुछ गोल्फों को याद किया है, लेकिन ...}

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

क्रिस हार्डविक का फॉर्मूला लागू करने वाला एक मोनडिक लिंक।

इसे ऑनलाइन आज़माएं! या टेस्ट-सूट (n=[1..33]) देखें।

Answer 12

CJam (47 बाइट्स)

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

ऑनलाइन डेमो

$$a(n) = \begin{cases} 1 & \textrm{ if } n \in \{0,1\} \\ 7! \times 3^6 & \textrm{ if } n=2 \\ a(n-1) \times 3\times 12!\times 2^{13} & \textrm{ if } n=3 \\ a(n-2) \times \left(\frac{24!}{24^6}\right)^{n-2} \times 24^6 & \textrm{ if } n>3 \end{cases}$$ j

Answer 13

जेली , 43 बाइट्स

_2²:4×6*@24
²_Ḥ:4;ḂU
“€ð‘!×⁽^K,1*ÇPד9Ḟɠ’:Ñ

इसे ऑनलाइन आज़माएं!

Answer 14

आइकन , 125 110 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 15

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

इसे ऑनलाइन आज़माएं!

Comments

N--*--N/4इसके बजाय सुझाव (N*N-2*N)/4दें और हटाएं N-=2और#define s mpz_init_set_str

— सीलिंगकैट

Answer 16

पर्ल 6 , 85 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 17

हास्केल , 86 85 74 बाइट्स

^{-1 बाइट ने H.PWiz
-11 बाइट्स की बदौलत मैक्स येकलाकोव की बदौलत बचा लिया}

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)

इसे ऑनलाइन आज़माएं!

Comments

24576से कम है2^13*3

— H.PWiz

74 बाइट्स इसे ऑनलाइन आज़माएं!

— मैक्स येखलाकोव

Answer 18

पायथन 2 , 92 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 19

हस्क , 51 48 44 बाइट्स

-4 बाइट्स H.PWiz को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

यह क्रिस हार्डविक का फॉर्मूला है। इसके अलावा, यह मेरा पहला भूसा कार्यक्रम है, इसलिए किसी भी सुझाव की सराहना की जाएगी।

Comments

यहाँ एक आसान 2 बाइट्स हैं:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12

— H.PWiz

या, अभी तक बेहतर है,÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12

— एचपीविज़

Answer 20

C ++, 187 185 180 176 195 (एक बग था) 193 175 बाइट्स (सीलिंग कैट की मदद से)

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

परीक्षण कोड के साथ, अपुष्ट

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

Comments

क्या आप शायद n=10परीक्षण मामले का स्क्रीनशॉट जोड़ सकते हैं, इसलिए मैं यह सत्यापित कर सकता हूं कि यह काम करता है? मुझे लगता है कि प्रयुक्त पुस्तकालय के कारण C ++ (क्लैंग) या C ++ (gcc) TIO पर यह काम करने का कोई तरीका नहीं है ?

— केविन क्रूज़सेन

argg। यह

— CSM

स्क्रीनशॉट के लिए धन्यवाद, और अच्छा है कि आप त्रुटि को इंगित करने और इसे ठीक करने में सक्षम हैं। मुझ से +1। :)

— केविन क्रूज़सेन

182 बाइट्स

— छत

ता @ceilingcat। #Define रिटर्न की कोई आवश्यकता नहीं है, क्योंकि केवल दो रिटर्न पॉइंट हैं

— CSM

Answer 21

टीआई-बेसिक, 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