एन-मूवर्स: मैं कितने अनंत बोर्ड तक पहुंच सकता हूं?

Question

एकल चाल

बोर्ड असीम शतरंज बोर्ड की तरह एक अनंत 2 आयामी वर्ग ग्रिड है। मान एन (एक एन-मॉवर ) वाला एक टुकड़ा किसी भी वर्ग को स्थानांतरित कर सकता है जो कि एन के वर्गमूल की वर्तमान वर्ग से दूरी है (यूक्लिडियन दूरी मापा केंद्र से केंद्र)।

उदाहरण के लिए:

• 1-मोवर क्षैतिज या लंबवत किसी भी वर्ग में जा सकता है
• 2-मोवर किसी भी वर्ग में जा सकता है जो तिरछे समीप है
• 5-मूवर शतरंज के शूरवीर की तरह चलता है

ध्यान दें कि सभी एन-मूवर्स नहीं चल सकते हैं। एक 3-मोवर अपने वर्तमान वर्ग को कभी नहीं छोड़ सकता क्योंकि बोर्ड पर कोई भी वर्ग वर्तमान वर्ग से ठीक 3 की दूरी पर नहीं है।

एकाधिक चाल

यदि बार-बार जाने की अनुमति है, तो कुछ टुकड़े बोर्ड पर किसी भी वर्ग तक पहुंच सकते हैं। उदाहरण के लिए, 1-प्रस्तावक और 5-प्रस्तावक दोनों ऐसा कर सकते हैं। एक 2-मोवर केवल तिरछे स्थानांतरित कर सकता है और केवल चौकों के आधे हिस्से तक पहुंच सकता है। एक टुकड़ा जो 3-मूवर की तरह नहीं चल सकता है, वह किसी भी वर्ग तक नहीं पहुंच सकता है (यदि कोई आंदोलन नहीं होता है तो शुरुआती वर्ग को "पहुंच" के रूप में गिना नहीं जाता है) ।

चित्र दिखाते हैं कि कौन से वर्ग तक पहुँचा जा सकता है। होवर पर अधिक जानकारी। बड़ी छवि के लिए क्लिक करें।

• 1 या अधिक चालों में उपलब्ध वर्गों को काले रंग में चिह्नित किया गया है
• ठीक 1 चाल में पहुंचने वाले वर्गों को लाल टुकड़ों द्वारा दिखाया गया है
  (3-प्रस्तावक के अलावा, जो स्थानांतरित नहीं हो सकता)

किसी दिए गए N-mover तक बोर्ड का अनुपात कितना हो सकता है?

इनपुट

• एक सकारात्मक पूर्णांक एन

उत्पादन

• बोर्ड का अनुपात जो एक एन-मूवर तक पहुंच सकता है
• यह 0 से 1 तक की संख्या है (दोनों समावेशी)
• इस चुनौती के लिए, 1/4 की तरह सबसे कम शब्दों में एक अंश के रूप में आउटपुट की अनुमति है

तो इनपुट के लिए 10, दोनों 1/2और 0.5स्वीकार्य outputs हैं। अलग-अलग अंश और हर के रूप में आउटपुट भी स्वीकार्य है, उन भाषाओं के समावेशी होने के लिए जो न तो तैरती हैं और न ही अंशों का समर्थन करती हैं। उदाहरण के लिए, 1 2या [1, 2]।

पूर्णांक आउटपुट (0 और 1) के लिए, निम्न में से कोई स्वीकार्य प्रारूप हैं:

• 0 के लिए: 0, 0.0, 0/1, 0 1,[0, 1]
• 1 के लिए: 1, 1.0, 1/1, 1 1,[1, 1]

स्कोरिंग

यह कोड गोल्फ है। स्कोर बाइट्स में कोड की लंबाई है। प्रत्येक भाषा के लिए, सबसे छोटा कोड जीतता है।

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

प्रारूप में input : output as fraction : output as decimal

  1 : 1     : 1
  2 : 1/2   : 0.5
  3 : 0     : 0
  4 : 1/4   : 0.25
  5 : 1     : 1
  6 : 0     : 0
  7 : 0     : 0
  8 : 1/8   : 0.125
  9 : 1/9   : 0.1111111111111111111111111111
 10 : 1/2   : 0.5
 13 : 1     : 1
 16 : 1/16  : 0.0625
 18 : 1/18  : 0.05555555555555555555555555556
 20 : 1/4   : 0.25
 25 : 1     : 1
 26 : 1/2   : 0.5
 64 : 1/64  : 0.015625
 65 : 1     : 1
 72 : 1/72  : 0.01388888888888888888888888889
 73 : 1     : 1
 74 : 1/2   : 0.5
 80 : 1/16  : 0.0625
 81 : 1/81  : 0.01234567901234567901234567901
 82 : 1/2   : 0.5
144 : 1/144 : 0.006944444444444444444444444444
145 : 1     : 1
146 : 1/2   : 0.5
148 : 1/4   : 0.25
153 : 1/9   : 0.1111111111111111111111111111
160 : 1/32  : 0.03125
161 : 0     : 0
162 : 1/162 : 0.006172839506172839506172839506
163 : 0     : 0
164 : 1/4   : 0.25
241 : 1     : 1
242 : 1/242 : 0.004132231404958677685950413223
244 : 1/4   : 0.25
245 : 1/49  : 0.02040816326530612244897959184
260 : 1/4   : 0.25
261 : 1/9   : 0.1111111111111111111111111111
288 : 1/288 : 0.003472222222222222222222222222
290 : 1/2   : 0.5
292 : 1/4   : 0.25
293 : 1     : 1
324 : 1/324 : 0.003086419753086419753086419753
325 : 1     : 1
326 : 0     : 0
360 : 1/72  : 0.01388888888888888888888888889
361 : 1/361 : 0.002770083102493074792243767313
362 : 1/2   : 0.5
369 : 1/9   : 0.1111111111111111111111111111
370 : 1/2   : 0.5
449 : 1     : 1
450 : 1/18  : 0.05555555555555555555555555556
488 : 1/8   : 0.125
489 : 0     : 0
490 : 1/98  : 0.01020408163265306122448979592
520 : 1/8   : 0.125
521 : 1     : 1
522 : 1/18  : 0.05555555555555555555555555556
544 : 1/32  : 0.03125
548 : 1/4   : 0.25
549 : 1/9   : 0.1111111111111111111111111111
584 : 1/8   : 0.125
585 : 1/9   : 0.1111111111111111111111111111
586 : 1/2   : 0.5
592 : 1/16  : 0.0625
593 : 1     : 1
596 : 1/4   : 0.25
605 : 1/121 : 0.008264462809917355371900826446
610 : 1/2   : 0.5
611 : 0     : 0
612 : 1/36  : 0.02777777777777777777777777778
613 : 1     : 1
624 : 0     : 0
625 : 1     : 1

Comments

मैंने यह प्रश्न Math.SE: math.stackexchange.com/questions/3108324/…

— infdirectory2047

दिलचस्प अनुमान!

— ट्राइकोप्लाक्स

"एक टुकड़ा जो 3-मुवर की तरह नहीं चल सकता है, किसी भी वर्ग तक नहीं पहुंच सकता है"। दिलचस्प रूप से पर्याप्त है, भले ही आप शुरुआती वर्ग की गणना करते हैं, क्योंकि बोर्ड अनंत है, फिर भी यह अनुपात के रूप में 0 में परिवर्तित होता है।

— बीफस्टर

@Beefster अच्छा बिंदु। मैं इस रास्ते के साथ अनंत तक सभी तरह से जाने के बिना सीमा को खोजने के लिए आसान बनाने के लिए चला गया ...

— ट्रिकोप्लाक्स पाद 13:00

@ infmagic2047 के प्राइम फैक्टरिंग दृष्टिकोण के बारे में math.se प्रश्न अब एक पूर्ण प्रमाण के साथ एक उत्तर है ।

— अर्जन जोहानसन

Answer 1

जावास्क्रिप्ट (Node.js) , 144 138 125 74 73 70 बाइट्स

f=(x,n=2,c=0)=>x%n?x-!c?f(x,n+1)/(n%4>2?n/=~c&1:n%4)**c:1:f(x/n,n,c+1)

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

-4 बाइट थैंक्स @Arnauld!

मूल दृष्टिकोण, 125 बाइट्स

a=>(F=(x,n=2)=>n*n>x?[x,0]:x%n?F(x,n+1):[n,...F(x/n,n)])(a).map(y=>r-y?(z*=[,1,.5,p%2?0:1/r][r%4]**p,r=y,p=1):p++,z=r=p=1)&&z

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

3Blue1Brown द्वारा प्रमुख नियमितताओं में छिपी वीडियो पाई से प्रेरित है ।

संख्या के गुणन में प्रत्येक अभाज्य कारक के लिए, गणना करें :$p^n$$f(p^n)$

• यदि विषम है और - । क्योंकि जाने की कोई जगह नहीं है।$n$$p\equiv 3\text{ (mod 4)}$$f(p^n)=0$
• यदि सम है और - ।$n$$p\equiv 3\text{ (mod 4)}$$f(p^n)=\frac{1}{p^n}$
• यदि - ।$p=2$$f(2^n)=\frac{1}{2^n}$
• यदि - ।$p\equiv 1\text{ (mod 4)}$$f(p^n)=1$

उन सभी फ़ंक्शन मानों को गुणा करें, जहां हम हैं।

अपडेट करें

Math.SE से योगदानकर्ताओं के प्रयास के लिए धन्यवाद, एल्गोरिथ्म अब एक प्रमाण द्वारा समर्थित है

Comments

क्या वीडियो में एक प्रमाण है? मैं अब कुछ घंटों के लिए इस परिणाम को साबित करने की कोशिश कर रहा हूं, लेकिन मैं इसका पता नहीं लगा सका।

— infmagic2047

$\sqrt{n}$

$q=\prod_{p\in\mathbb{P}\land p\in\{2,3\}\text{ (mod 4)}}p^{e_p}$

इस दृष्टिकोण के बारे में @ infmagic2047 के गणित के सवाल का अब पूर्ण प्रमाण के साथ उत्तर है ।

— अर्जन जोहान्सन

Answer 2

मैथेमेटिका, 80 बाइट्स

d[n_]:=If[#=={},0,1/Det@LatticeReduce@#]&@Select[Tuples[Range[-n,n],2],#.#==n&];

यह कोड ज्यादातर गणितीय प्रमेय पर निर्भर है। मूल विचार यह है कि कोड किसी उत्पन्न सेट को दिए गए जाली के घनत्व के लिए पूछता है।

अधिक सटीक रूप से, हमें वैक्टर के कुछ संग्रह दिए गए हैं - अर्थात्, जिनकी लंबाई एन है - और सभी पूर्णांक वैक्टरों की तुलना में इन वैक्टरों के संभावित योग के घनत्व की गणना करने के लिए कहा जाता है। नाटक में गणित यह है कि हम हमेशा दो वैक्टर (और उनके विपरीत) पा सकते हैं जो "जेनरेट" करते हैं (यानी जिनके गुण हैं) मूल संग्रह के समान सेट। LatticeReduce बिल्कुल यही करता है।

यदि आपके पास सिर्फ दो वैक्टर हैं, तो आप प्रत्येक अभिकर्मक बिंदु पर केंद्रित समान समांतर चतुर्भुज को आरेखित करने की कल्पना कर सकते हैं, लेकिन जिसकी किनारे की लंबाई दिए गए वैक्टर हैं, जैसे कि विमान इन समांतर चतुर्भुज द्वारा पूरी तरह से टाइल किया गया है। (उदाहरण के लिए, n = 2 के लिए "डायमंड" आकृतियों का एक जालीदार चित्र)। प्रत्येक समांतर चतुर्भुज का क्षेत्रफल दो उत्पन्न करने वाले वैक्टर का निर्धारक होता है। विमान का वांछित अनुपात इस क्षेत्र का पारस्परिक है, क्योंकि प्रत्येक समांतर चतुर्भुज में बस एक पहुंच बिंदु होता है।

कोड एक काफी सरल कार्यान्वयन है: वैक्टर उत्पन्न करें, LatticeReduce का उपयोग करें, निर्धारक को लें, फिर पारस्परिक ले जाएं। (यह शायद बेहतर गोल्फ हो सकता है, हालांकि)

Comments

76 बाइट्स:d@n_:=Boole[#!={}]/Det@LatticeReduce@#&@Select[Range[-n,n]~Tuples~2,#.#==n&]

— u54112

Answer 3

क्लीन , 189 185 172 171 बाइट्स

import StdEnv
$n#r=[~n..n]
#p=[[x,y]\\x<-r,y<-r|x^2+y^2==n]
=sum[1.0\\_<-iter n(\q=removeDup[k\\[a,b]<-[[0,0]:p],[u,v]<-q,k<-[[a+u,b+v]]|all(\e=n>=e&&e>0)k])p]/toReal(n^2)

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

nपहले चतुर्भुज में मूल पर उल्टे-लम्बे चौकोर वर्गाकार में उपलब्ध हर स्थिति को ढूँढता है , फिर n^2सभी कोशिकाओं के भाग को प्राप्त करने के लिए विभाजित करता है ।

यह काम करता है क्योंकि:

• पूरे पहुंच योग्य विमान को इस n-उल-लंबाई वर्ग की ओवरलैपिंग प्रतियों के रूप में माना जा सकता है , प्रत्येक मूल से एक पहुंच योग्य बिंदु पर स्थित है जैसे कि यह मूल था।
• सभी आंदोलनों को संकेतों के साथ चार के समूह में आते हैं ++ +- -+ --, ओवरलैपिंग टाइलिंग को मिररिंग और रोटेशन द्वारा अन्य तीन क्वाडंट के माध्यम से विस्तारित करने की अनुमति मिलती है।

Comments

मेरी क्षमायाचना - मैं उन परीक्षण मामलों को देख रहा था जो N = 10 से N = 13 तक जाते हैं, जबकि आपके परीक्षण मामलों में N = 11 और N = 12 भी शामिल हैं। आप वास्तव में N = 13 के लिए सही हैं। मुझ से +1 :)

— ट्राइकोप्लाक्स

@trichoplax मैं फिर से उसी उलझन से बचने के लिए प्रश्न के अनुरूप करने के लिए परीक्षण बदल दिया है

— 11urous

मैंने आगे N = 145 तक परीक्षण किया है और सभी सही हैं। मैं 60 सेकंड के समय के कारण TIO पर 146 का परीक्षण नहीं कर सका। मैं यहाँ जवाब में कुछ बहुत लंबे समय की उम्मीद कर रहा हूँ ...

— ट्राइकोप्लाक्स

चूँकि मुझे यह महसूस करने में थोड़ा समय लगा: यदि कम से कम एक चाल (ए, बी) है तो चौकोर कोने फिर से आने योग्य हैं, यह जटिल समीकरण है (a + bi) (a-bi) = a ^ 2 + b ^ 2, जो वेक्टर रूप में बन जाता है (N, 0) = a (b, + b) (b, -a)।

— अर्जन जोहान्सन

Answer 4

रेटिना 0.8.2 , 126 82 बाइट्स

.+
$*
+`^(1(1111)+)(?<!^\3+(11+))(\1)*$
1$#4$*
^(?!((^1|11\2)+)\1?$)1+
0
11+
1/$.&

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
$*

यूनीरी में बदलें।

+`^(1(1111)+)(?<!^\3+(11+))(\1)*$
1$#4$*

प्रपत्र के प्रमुख कारकों द्वारा बार-बार विभाजित 4k+1।

^(?!((^1|11\2)+)\1?$)1+
0

यदि परिणाम न तो एक वर्ग है और न ही दो बार एक वर्ग है तो परिणाम शून्य है।

11+
1/$.&

दशमलव अंश के रूप में पारस्परिक गणना करें।

Answer 5

रेगेक्स (ECMAScript, पारस्परिक बाहर), 256 163 157 94 83 82 बाइट्स

-93 बाइट्स नील
-6 बाइट्स की बदौलत फिर से नील
-63 बाइट्स
के लिए धन्यवाद, डिविज़र -11 बाइट्स पर कब्जा किए बिना ग्रिम के साथ-साथ वैकल्पिक-डिवीजन-बाय-कंसिस्टेंट और स्क्वायर रूट -1 बाइट्स को एंड-मैच की स्थिति में ले जाकर धन्यवाद।
और ग्रिम के लिए धन्यवाद, दूसरे विकल्प के रूप में लूप पर कब्जा कर लेते हैं

यह Shieru Asakoto के जावास्क्रिप्ट उत्तर के समान गणित का उपयोग करता है ।

इनपुट अनियंत्रित है। चूंकि शुद्ध रेगेक्स केवल आउटपुट से इनपुट के रूप में वापस आ सकता है (यानी इनपुट से कम या इसके बराबर कोई प्राकृतिक संख्या), या "कोई मेल नहीं", यह रेगेक्स बोर्ड के अनुपात का पारस्परिक रिटर्न देता है जो कि एन-मूवर है पहुँच सकता है। चूंकि 0 का पारस्परिक प्रभाव अनंत है, यह उस मामले में "कोई मैच नहीं" देता है।

स्पिनर चेतावनी : वर्गमूल के लिए, यह रेगेक्स सामान्यीकृत गुणन एल्गोरिथ्म के एक प्रकार का उपयोग करता है, जो गैर-स्पष्ट है और अपने दम पर काम करने के लिए एक पुरस्कृत पहेली हो सकता है। अधिक जानकारी के लिए, Find Rocco नंबर में एल्गोरिथ्म के इस रूप के लिए एक स्पष्टीकरण देखें ।

$p$$p\equiv 1\text{ (mod 4)}$$m$$m$$\equiv 3\text{ (mod 4)}$$m$$m/2$$m$$m$

$m$$m/2$$p$$\equiv 3\text{ (mod 4)}$

^(?=((?=(x+)(?!(\2+)(\2\3)+$)((\2{4})+$))\5|((xx?)(\8*))(?=(\7*)\9+$)\7*$\10)+$)\1

इसे ऑनलाइन आज़माएं!
इसे ऑनलाइन आज़माएं! (सिर्फ परीक्षण मामलों)

^
(?=
    (                          # Capture return value, which will just be the value
                               # matched by the last iteration of this loop.
    # Divide tail by every one of its prime factors that's ≡1 mod 4, as many times as
    # possible.
        (?=
            (x+)               # \2 = quotient
            (?!(\2+)(\2\3)+$)  # Assert divisor is prime
            ((\2{4})+$)        # Assert divisor ≡1 mod 4; \5 = tool to make tail = \2
        )\5                    # tail = \2
    |
    # When the above alternative has been done as many times as possible:
    # Test if tail or tail/2 is a perfect square. If this test fails, the regex engine
    # will backtrack into the division loop above, and run the same perfect square
    # test on every previous number (effectively "multiplying" it by each previous P
    # in reverse, one at a time). This will not cause a failure of the test to change
    # into a success, however, because the odd power of a prime ≡3 mod 4 will see be
    # present in the number at every step. Allowing this backtracking to happen is a
    # golf optimization, and it does make the regex slower.
    # Failure of this perfect square test results in returning "no match" and indicates
    # a return value of zero.
        (                      # \7 = \8 * sqrt(tail / \8)
            (xx?)              # \8 = control whether to take sqrt(tail)
                               #                         or 2*sqrt(tail/2)
            (\8*)              # \9 = \7 - \8
        )
        (?=
            (\7*)\9+$          # Iff \8 * (\7 / \8)^2 == our number, then the first match
                               # here must result in \10==0
        )
        \7*$\10                # Test for divisibility by \7 and for \10==0
                               # simultaneously
    )+
    $                          # Require that the last iteration of the above loop was
                               # the perfect square test. Since the first alternative,
                               # the division, always leaves >=1 in tail, this guarantees
                               # that the last step is a successful perfect square test,
                               # or else the result will be "no match".
)
\1                             # Return value (which is a reciprocal)

रेगेक्स (ECMAScript + (? *), पारस्परिक उत्पादन), 207 138 132 बाइट्स

विभाजक (यानी अब ऊपर के समान है) को कैप्चर किए बिना विभाजन करके किया गया।

रेगेक्स (ECMAScript 2018, पारस्परिक उत्पादन), 212 140 134 बाइट्स

विभाजक (यानी अब ऊपर के समान है) को कैप्चर किए बिना विभाजन करके किया गया।

रेगेक्स (ECMAScript, अंश आउटपुट), 80 बाइट्स

इस संस्करण में, अंश में वापस किया जाता है \10(शून्य में अगर / एनपीसीजी) और में भाजक \7।

पारस्परिक आउटपुट संस्करण के विपरीत:

• शून्य का इनपुट सही तरीके से निपटाया नहीं गया है (यह उस संस्करण की तरह ही "नो मैच" देता है, लेकिन इसके विपरीत, यह शून्य के आउटपुट मूल्य के अनुरूप नहीं है)।
• यदि सही वर्ग परीक्षण विफल हो जाता है, तो यह विभाजन पाश में पीछे नहीं हटता है, इसलिए निष्पादन समय में यह संस्करण अधिक कुशल है।

इस तरह एक आउटपुट विनिर्देश का बड़ा नकारात्मक पहलू यह है कि यह कार्यक्रम में ही निहित नहीं है।

((?=(x+)(?!(\2+)(\2\3)+$)((\2{4})+$))\5)*((((x)x?)(\9*))(?=(\8*)\11+$)\8*$\12|x)

इसे ऑनलाइन आज़माएं!
इसे ऑनलाइन आज़माएं! (सिर्फ परीक्षण मामलों)

# No need to anchor, since we return a match for all inputs in the domain.
# Divide tail by every one of its prime factors that's ≡1 mod 4
(
    (?=
        (x+)               # \2 = quotient
        (?!(\2+)(\2\3)+$)  # Assert divisor is prime
        ((\2{4})+$)        # Assert divisor ≡1 mod 4; \5 = tool to make tail = \2
    )\5                    # tail = \2
)*
# Test if tail or tail/2 is a perfect square. If this test succeeds, return tail as
# the denominator and 1 as the numerator.
(                          # \7 = denominator output
    (                      # \8 = \9 * sqrt(tail / \9)
        ((x)x?)            # \9 = control whether to take sqrt(tail) or 2*sqrt(tail/2);
                           # \10 = numerator output (NPCG to represent zero)
        (\9*)              # \11 = \8 - \9
    )
    (?=
        (\8*)\11+$         # Iff \9 * (\8 / \9)^2 == our number, then the first match
                           # here must result in \12==0
    )
    \8*$\12                # Test for divisibility by \8 and for \12==0
                           # simultaneously
|
# Failure of the perfect square test results in returning 0/1 as the answer, so here
# we return a denominator of 1.
    x
)

Comments

क्षमा करें, मैंने स्पष्ट रूप से पर्याप्त परीक्षण मामलों पर इसकी कोशिश नहीं की।

— नील

@trichoplax क्या आप दो विशिष्ट कैप्चर समूहों की लंबाई के अनुपात के रूप में उत्तर पर विचार कर सकते हैं? (यह वास्तव में जवाब को छोटा बना देगा क्योंकि यह पूरे मैच का परिणाम बनाने के लिए परेशानी का कारण

— नील

@ नील की टिप्पणी के बाद, मैंने आउटपुट को अलग-अलग अंश और हर के रूप में अनुमति देने के लिए संपादित किया है, क्योंकि यह सबसे छोटा बदलाव है जो शुद्ध रेगेक्स के लिए अनुमति देता है। मुझे पता है कि अगर अभी भी एक समस्या है

— ट्राइकोप्लाक्स

(((xx?)(\9*))(?=(\8*)\10+$)\8*$\11)N या ​​N / 2 एक वर्ग है या नहीं, यह देखने के लिए -11 बाइट्स ।

— ग्रिमी

@Deadcode पॉइंटर्स बैकरेफ़ को बाइट कॉस्ट नहीं दी जानी चाहिए , क्योंकि वे डिफ़ॉल्ट रूप से अनुमति देते हैं ।

— ग्रैमी

Answer 6

जेली ,  25  24 बाइट्स

ÆFµ%4,2CḄ:3+2Ịị,*/ʋ÷*/)P

प्राइम फैक्टर रूट का उपयोग करके एक विवादास्पद लिंक।

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

कैसे?

ÆFµ%4,2CḄ:3+2Ịị,*/ʋ÷*/)P - Link: integer, n               e.g. 11250
ÆF                       - prime factor, exponent pairs        [[2,1], [3,2], [5,4]]
  µ                   )  - for each pair [F,E]:
    4,2                  -   literal list [4,2]
   %                     -   modulo (vectorises)                [2,1]  [3,0]  [1,0]
       C                 -   complement (1-x)                  [-1,0] [-2,1]  [0,1]
        Ḅ                -   from base 2                         -2     -3      1      
         :3              -   integer divide by three             -1     -1      0
           +2            -   add two (call this v)                1      1      3
                  ʋ      -   last four links as a dyad, f(v, [F,E])
             Ị           -     insignificant? (abs(x)<=1 ? 1 : 0)   1      1      0
                */       -     reduce by exponentiation (i.e. F^E)  2      9     625
               ,         -     pair v with that                   [1,2]  [1,9]  [3,625]
              ị          -     left (Ị) index into right (that)     1      1     625
                    */   -   reduce by exponentiation (i.e. F^E)    2      9     625
                   ÷     -   divide                                1/2    1/9  625/625
                       P - product                                 1/18 = 0.05555555555555555

---

पिछला 25 था:

ŒRp`²S⁼ɗƇ⁸+€`Ẏ;Ɗ%³QƊÐLL÷²

पूर्ण कार्यक्रम जानवर का वध ; प्रमुख कारक मार्ग की तुलना में संभवतः अधिक लंबा कोड (मैं बाद में प्रयास कर सकता हूं)।

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

निर्देशांकों के रूप में एक चाल तो बार-बार परिणाम जमा सभी तक पहुँच स्थानों से चलता रहता है बनाने, सापेक्ष लेने के द्वारा शुरू होता है nप्रत्येक के समन्वय (एक को प्रतिबंधित करने के लिए nद्वारा nवृत्त का चतुर्थ भाग) और वे जो अलग हैं जब तक एक निश्चित बिंदु पर पहुंच गया है रखने; फिर अंत में गिनती को विभाजित करता हैn^2

Answer 7

05AB1E , 27 26 25 बाइट्स

ÓεNØ©<iozë®4%D≠iyÈ®ymz*]P

पोर्ट @ShieruAsakoto के जावास्क्रिप्ट उत्तर है , इसलिए उसे भी उखाड़ना सुनिश्चित करें!

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Ó                   # Get all prime exponent's of the (implicit) input's prime factorization
                    #  i.e. 6 → [1,1]      (6 → 2**1 * 3**1)
                    #  i.e. 18 → [1,2]     (18 → 2**1 * 3**2)
                    #  i.e. 20 → [2,0,1]   (20 → 2**2 * 3**0 * 5**1)
                    #  i.e. 25 → [0,0,2]   (25 → 2**0 * 3**0 * 5**2)
 ε                  # Map each value `n` to:
  NØ                #  Get the prime `p` at the map-index
                    #   i.e. map-index=0,1,2,3,4,5 → 2,3,5,7,11,13
    ©               #  Store it in the register (without popping)
     <i             #  If `p` is exactly 2:
       oz           #   Calculate 1/(2**`n`)
                    #    i.e. `n`=0,1,2 → 1,0.5,0.25
      ë             #  Else:
       ®4%          #   Calculate `p` modulo-4
                    #    i.e. `p`=3,5,7,11,13 → 3,1,3,3,1
          D         #   Duplicate the result (the 1 if the following check is falsey)
           ≠i       #   If `p` modulo-4 is NOT 1 (in which case it is 3):
             yÈ     #    Check if `n` is even (1 if truthy; 0 if falsey)
                    #     i.e. `n`=0,1,2,3,4 → 1,0,1,0,1
             ®ymz   #    Calculate 1/(`p`**`n`)
                    #     i.e. `p`=3 & `n`=2 → 0.1111111111111111 (1/9)
                    #     i.e. `p`=7 & `n`=1 → 0.14285714285714285 (1/7)
              *     #    Multiply both with each other
                    #     i.e. 1 * 0.1111111111111111 → 0.1111111111111111
                    #     i.e. 0 * 0.14285714285714285 → 0
 ]                  # Close both if-statements and the map
                    #  i.e. [1,1] → [0.5,0.0]
                    #  i.e. [1,2] → [0.5,0.1111111111111111]
                    #  i.e. [2,0,1] → [0.25,1.0,1]
                    #  i.e. [0,0,2] → [1.0,1.0,1]
  P                 # Take the product of all mapped values
                    #  i.e. [0.5,0.0] → 0.0
                    #  i.e. [0.5,0.1111111111111111] → 0.05555555555555555
                    #  i.e. [0.25,1.0,1] → 0.25
                    #  i.e. [1.0,1.0,1] → 1.0
                    # (and output implicitly as result)

Answer 8

APL (Dyalog Extended) , 21 बाइट्स

यह प्रोग्राम प्राइम फैक्टर रूट का उपयोग करता है। मैं Adám, dzaima, H.PWiz, J.Sallé, और ngn का ऋणी हूं। एपीएल ऑर्चर्ड एपीएल सीखने के लिए एक शानदार जगह है और वे हमेशा मदद के लिए तैयार रहते हैं

(×/÷,3≠4|*∘≢⌸)⍭*1≠4|⍭

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

Ungolfing

इस कोड का भाग 2 नीचे दिए गए Dyalog यूनिकोड संस्करण के समान है, और इसलिए इस स्पष्टीकरण में, मैं इस पर ध्यान केंद्रित करूंगा ⍭*1≠4|⍭

⍭*1≠4|⍭

      ⍭  Gives us a list of the prime factors of our input.
           Example for 45: 3 3 5
  1≠4|   Checks if each prime is of the form 4k+1.
⍭*       Takes each prime to the power of 1 or 0,
           turning all the 4k+1 primes into 1s.
           Example for 45: 3 3 1

---

एपीएल (डायलॉग यूनिकोड) , 41 40 36 35 बाइट्स ^{एसबीसीएस}

यह प्रोग्राम प्राइम फैक्टर रूट का उपयोग करता है। इसे लिखते समय कुछ तरकीबें सीखीं और मैं Adám, dzaima, H.PWiz, J.Sallé, और ngn का गहराई से ऋणी हूं। APL Orchard APL सीखने के लिए एक शानदार जगह है और वे हमेशा मदद करने के लिए तैयार रहते हैं (या यह पोस्ट कभी भी बंद नहीं हुई होगी :)

संपादित करें: ngn से -1 बाइट। Adám से -2 बाइट्स और ngn से -2 अधिक। Ngn से -1 बाइट।

{(×/÷,3≠4|*∘≢⌸)p*1≠4|p←¯2÷/∪∧\⍵∨⍳⍵}

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

Ungolfing

यह दो भागों में एक कार्यक्रम है:

p*1≠4|p←¯2÷/∪∧\⍵∨⍳⍵  Part 1

      p←             We can define variables mid-dfn (a function in {} brackets).
               ⍵∨⍳⍵  We take the GCD of our input 
                       with every member of range(1, input).
            ∪∧\      This returns all the unique LCMs of every prefix
                       of our list of GCDs.
                       Example for 31500: 1 2 6 12 60 420 1260 6300 31500
        ¯2÷/         We divide pairwise (and in reverse)
                       by using a filter window of negative two (¯2).
                       Example for 31500: 2 3 2 5 7 3 5 5
  1≠4|p              Check if the primes are 1 modulo 4 or not
p*                   And take each prime to the power of the result (1 or 0),
                       turning the 4k+3 primes into 1s
                       and leaving any 2s and 4k+3 primes.
                       Example for 31500: 2 3 2 1 7 3 1 1

(×/÷,3≠4|*∘≢⌸)  Part 2

(            )  We apply all this to the filtered array of primes.
         *∘≢⌸   This takes all of our primes to their exponents
                  (the number of times those primes appear in the factorization).
                  Example for 31500: 4 9 1 7
     3≠4|       Then we take each prime modulo 4 and check if not equal to 3.
                  We will only get a falsey if any 4k+3 primes, as an even number of
                  4k+3 primes multiplied together will result in some 4m+1.
                  Example for 31500: 1 1 1 0
   ÷,           We append the results of the above condition check
                  to the reciprocals of the primes in p.
                  Example for 31500: (1/2) (1/3) (1/2) 1 (1/7) (1/3) 1 1 1 1 1 0
 ×/             We multiply it all together, resulting in a positive fraction or 0
                  depending on our condition check.
                  Example for 31500: 0
                We return the results of all our checks implicitly.