ย้ายเดี่ยว

กระดานเป็นตารางสี่เหลี่ยมสองมิติที่ไม่มีที่สิ้นสุดเช่นกระดานหมากรุกที่ไร้ขีด จำกัด ชิ้นส่วนที่มีค่า N ( N-mover ) สามารถย้ายไปยังจตุรัสใดก็ได้ที่มีระยะทางเท่ากับรากที่สองของ N จากสแควร์ปัจจุบัน

ตัวอย่างเช่น:

• ผู้เสนอญัตติ 1 สามารถย้ายไปยังตารางใด ๆ ที่อยู่ติดกันในแนวนอนหรือแนวตั้ง
• ผู้เสนอญัตติ 2 สามารถย้ายไปยังตารางใด ๆ ที่อยู่ติดกันในแนวทแยงมุม
• ผู้เสนอญัตติ 5 เท่าเคลื่อนไหวเหมือนหมากรุกอัศวิน

โปรดทราบว่าตัวย้าย N-movers บางคนไม่สามารถเคลื่อนย้ายได้ ผู้เสนอญัตติ 3 คนไม่สามารถออกจากจตุรัสปัจจุบันได้เพราะไม่มีสแควร์สบนกระดานเป็นระยะทางของรูท 3 จากสแควร์ปัจจุบัน

การเคลื่อนไหวหลายครั้ง

หากได้รับอนุญาตให้ย้ายซ้ำหลาย ๆ ชิ้นสามารถไปถึงช่องสี่เหลี่ยมบนกระดานได้ ตัวอย่างเช่นผู้เสนอญัตติ 1 และ 5 ผู้มีอิทธิพลสามารถทำได้ ผู้เสนอญัตติ 2 สามารถเคลื่อนที่ในแนวทแยงมุมและสามารถเข้าถึงครึ่งหนึ่งของสี่เหลี่ยม ชิ้นส่วนที่ไม่สามารถเคลื่อนย้ายได้เช่นเดียวกับ 3 ผู้เสนอญัตติไม่สามารถเข้าถึงใด ๆ ของสี่เหลี่ยม(ตารางที่เริ่มต้นจะไม่นับเป็น "ถึง" ถ้าไม่มีการเคลื่อนไหวเกิดขึ้น)

ภาพแสดงสี่เหลี่ยมที่สามารถเข้าถึงได้ รายละเอียดเพิ่มเติมเกี่ยวกับการโฮเวอร์ คลิกเพื่อดูรูปขนาดใหญ่

• สี่เหลี่ยมที่เข้าถึงได้ในการเคลื่อนไหวอย่างน้อย 1 ครั้งจะถูกทำเครื่องหมายด้วยสีดำ
• สี่เหลี่ยมที่เข้าถึงได้ในการเคลื่อนไหว 1 ครั้งนั้นจะแสดงเป็นชิ้นสีแดง
  (นอกเหนือจาก 3 ผู้เสนอญัตติซึ่งไม่สามารถเคลื่อนที่ได้)

สัดส่วนใดของกระดานที่ N-mover สามารถเข้าถึงได้?

อินพุต

• จำนวนเต็มบวก N

เอาท์พุต

• สัดส่วนของกระดานที่ N-mover สามารถเข้าถึงได้
• นี่คือตัวเลขตั้งแต่ 0 ถึง 1 (รวมทั้งคู่)
• สำหรับความท้าทายนี้อนุญาตให้ส่งออกเป็นเศษส่วนด้วยคำต่ำสุดเช่น 1/4 ได้

ดังนั้นสำหรับอินพุต10ทั้งสอง1/2และ0.5เป็นเอาต์พุตที่ยอมรับได้ เอาท์พุทเป็นตัวแยกตัวเลขและตัวหารก็เป็นที่ยอมรับเช่นกันเพื่อรวมภาษาที่รองรับทั้งการลอยหรือการแยก ยกตัวอย่างเช่นหรือ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

JavaScript (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 ทำให้อัลกอริทึมได้รับการสนับสนุนโดยการพิสูจน์แล้ว

Mathematica, 80 ไบต์

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

รหัสนี้ส่วนใหญ่พึ่งพาทฤษฎีบทคณิตศาสตร์ แนวคิดพื้นฐานคือรหัสจะถามถึงความหนาแน่นของโครงตาข่ายที่กำหนดชุดการสร้าง

อย่างแม่นยำยิ่งขึ้นเราได้รับชุดของเวกเตอร์ - กล่าวคือพวกที่ความยาวกำลังสองคือ N - และขอให้คำนวณความหนาแน่นของเซตผลบวกที่เป็นไปได้ของเวกเตอร์เหล่านี้เทียบกับจำนวนเต็มเวกเตอร์ทั้งหมด คณิตศาสตร์ที่เล่นคือเราสามารถหาเวกเตอร์สองตัว (และด้านตรงข้าม) ที่ "สร้าง" (เช่นจำนวนผลบวก) ชุดเดียวกันกับคอลเลกชันดั้งเดิม LatticeReduce ทำสิ่งนั้นอย่างแน่นอน

หากคุณมีเวกเตอร์เพียงสองตัวคุณสามารถนึกภาพการวาดสี่เหลี่ยมด้านขนานที่เหมือนกันโดยมีศูนย์กลางอยู่ที่แต่ละจุดที่เข้าถึงได้ แต่ความยาวของขอบนั้นเป็นเวกเตอร์ที่ให้มา (ลองนึกภาพตัวอย่างเช่นขัดแตะ "เพชร" รูปร่างสำหรับ n = 2) พื้นที่ของสี่เหลี่ยมด้านขนานแต่ละอันนั้นเป็นตัวกำหนดของเวกเตอร์ที่สร้างสองตัว สัดส่วนที่ต้องการของระนาบคือส่วนกลับของพื้นที่นี้เนื่องจากแต่ละสี่เหลี่ยมด้านขนานมีจุดเข้าถึงได้เพียงจุดเดียว

รหัสเป็นการดำเนินการที่ค่อนข้างตรงไปตรงมา: สร้างพาหะใช้ LatticeReduce ใช้ดีเทอร์มิแนนต์แล้วนำกลับมาใช้ (มันอาจจะดีกว่า golfed แม้ว่า)

ทำความสะอาด , 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สี่เหลี่ยมจัตุรัสยาวด้านนี้แต่ละมุมจะอยู่ในจุดที่สามารถเข้าถึงได้จากจุดกำเนิดราวกับว่ามันเป็นจุดกำเนิด
• การเคลื่อนไหวทั้งหมดมาในกลุ่มที่สี่ที่มีสัญญาณ++ +- -+ --อนุญาตให้เรียงต่อกันที่ทับซ้อนกันจะขยายผ่านอีกสามภาคโดยการสะท้อนและการหมุน

เรติน่า 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/$.&

คำนวณส่วนกลับซึ่งเป็นเศษส่วนทศนิยม

Regex (ECMAScript, reciprocal out), 256 163 157 94 83 82 ไบต์

-93 ไบต์ขอบคุณ Neil
-6 ไบต์ขอบคุณอีกครั้งกับ Neil
-63 ไบต์โดยทำการหารโดยไม่ต้องจับตัวหาร
-11 ไบต์ขอบคุณGrimy พร้อมกันตัวเลือกการหารโดยคงที่และรากที่สองพร้อมกัน
-1 ไบต์โดยการย้ายเงื่อนไขการแข่งขันจบ และคืนค่าการจับภาพลงในลูปเป็นทางเลือกที่สองขอบคุณ Grimy

สิ่งนี้ใช้คณิตศาสตร์แบบเดียวกับ คำตอบ JavaScript Shieru Asakoto ของ

อินพุตไม่พร้อมกัน เนื่องจากบริสุทธิ์ regex สามารถกลับเป็นเอาต์พุตย่อยจากอินพุต (เช่นจำนวนธรรมชาติน้อยกว่าหรือเท่ากับอินพุต) หรือ "ไม่ตรงกัน", regex นี้ส่งกลับส่วนกลับของสัดส่วนของกระดานที่ N-mover สามารถเข้าถึง เนื่องจากส่วนกลับของ 0 เป็นอนันต์จึงส่งกลับ "no match" ในกรณีนั้น

คำเตือนสปอยเลอร์ : สำหรับสแควร์รูท regex นี้ใช้ตัวแปรของอัลกอริทึมการคูณแบบทั่วไปซึ่งไม่ชัดเจนและอาจเป็นปริศนาที่ให้รางวัลในการทำงานด้วยตัวคุณเอง สำหรับข้อมูลเพิ่มเติมโปรดดูคำอธิบายสำหรับรูปแบบของขั้นตอนวิธีการนี้ในการหาจำนวนร็อคโค

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

Regex (ECMAScript + (? *), เอาต์พุตส่วนกลับ), 207 138 132ไบต์

ล้าสมัยโดยการแบ่งโดยไม่ต้องจับตัวหาร (เช่นตอนนี้เหมือนด้านบน)

Regex (ECMAScript 2018, เอาต์พุตส่วนกลับ), 212 140 134ไบต์

ล้าสมัยโดยการแบ่งโดยไม่ต้องจับตัวหาร (เช่นตอนนี้เหมือนด้านบน)

Regex (ECMAScript, เอาต์พุตเศษส่วน), 80 ไบต์

ในรุ่นนี้เศษถูกส่งกลับใน\10(ศูนย์ถ้าไม่มีการตั้งค่า / NPCG) \7และส่วนใน

ต่างจากเวอร์ชั่นเอาท์พุทซึ่งกันและกัน:

• อินพุตของศูนย์ไม่ได้รับการจัดการอย่างถูกต้อง (จะส่งกลับ "no match" เช่นเดียวกับเวอร์ชันนั้น แต่ไม่เหมือนกับมันที่ไม่สอดคล้องกับค่าเอาต์พุตของศูนย์)
• หากการทดสอบรูปสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบล้มเหลวมันจะไม่ย้อนรอยย้อนกลับไปยังส่วนวนซ้ำดังนั้นเวอร์ชันนี้จะมีประสิทธิภาพมากขึ้นในเวลาดำเนินการ

ข้อเสียใหญ่ของสเปคเอาท์พุทเช่นนี้คือมันไม่ได้อยู่ในโปรแกรม

((?=(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
)

เยลลี่ ,  25  24 ไบต์

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

ลิงก์ monadic ใช้เส้นทางปัจจัยหลัก

ลองออนไลน์!

อย่างไร?

Æ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

05AB1E , 27 26 25 ไบต์

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

คำตอบ JavaScriptของพอร์ตของ@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)

APL (ขยาย Dyalog) , 21 ไบต์

โปรแกรมนี้ใช้เส้นทางตัวประกอบหลัก ฉันเป็นหนี้บุญคุณต่อAdám, dzaima, H.PWiz, J.Salléและ ngn APL Orchardเป็นสถานที่ที่ยอดเยี่ยมในการเรียนรู้ APL และพวกเขายินดีช่วยเหลือเสมอ

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

ลองออนไลน์!

Ungolfing

ส่วนที่ 2 ของรหัสนี้เหมือนกับใน Dyalog Unicode version ด้านล่างและในคำอธิบายนี้ฉันจะเน้น ⍭*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

APL (Dyalog Unicode) , 41 40 36 35 ไบต์^SBCS

โปรแกรมนี้ใช้เส้นทางตัวประกอบหลัก เรียนรู้เทคนิคสองสามข้อในขณะที่เขียนบทความนี้และฉันรู้สึกเป็นหนี้บุญคุณต่อAdám, dzaima, H.PWiz, J.Salléและ ngn APL Orchardเป็นสถานที่ที่ยอดเยี่ยมในการเรียนรู้ APL และพวกเขายินดีที่จะช่วยเหลือเสมอ (หรือโพสต์นี้จะไม่มีวันหลุดจากพื้นดิน :)

แก้ไข: -1 ไบต์จาก ngn -2 ไบต์จากAdámและ -2 เพิ่มเติมจาก ngn -1 ไบต์จาก ngn

{(×/÷,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.