Di chuyển đơn

Bàn cờ là một lưới vuông 2 chiều vô hạn, giống như một bàn cờ vô hạn. Một mảnh có giá trị N (một N-mover ) có thể di chuyển đến bất kỳ hình vuông nào có khoảng cách chính xác là căn bậc hai của N từ hình vuông hiện tại của nó (khoảng cách Euclide đo đến tâm).

Ví dụ:

• Động cơ 1 có thể di chuyển đến bất kỳ hình vuông nào liền kề theo chiều ngang hoặc chiều dọc
• Một động cơ 2 có thể di chuyển đến bất kỳ hình vuông nào liền kề theo đường chéo
• Một động tác 5 bước như một hiệp sĩ cờ vua

Lưu ý rằng không phải tất cả N-movers đều có thể di chuyển. Một động cơ 3 không bao giờ có thể rời khỏi hình vuông hiện tại của nó bởi vì không có hình vuông nào trên bảng là khoảng cách chính xác của căn 3 so với hình vuông hiện tại.

Nhiều di chuyển

Nếu được phép di chuyển nhiều lần, một số mảnh có thể chạm tới bất kỳ hình vuông nào trên bảng. Ví dụ, cả 1 động cơ và 5 động cơ đều có thể làm điều này. Một động cơ 2 chỉ có thể di chuyển theo đường chéo và chỉ có thể đạt được một nửa hình vuông. Một mảnh không thể di chuyển, như động cơ 3, không thể chạm tới bất kỳ hình vuông nào ( hình vuông bắt đầu không được tính là "đạt" nếu không có chuyển động xảy ra) .

Các hình ảnh cho thấy những hình vuông có thể đạt được. Thêm chi tiết về di chuột. Nhấn vào đây để xem hình ảnh lớn hơn.

• Hình vuông có thể tiếp cận trong 1 hoặc nhiều di chuyển được đánh dấu màu đen
• Các ô vuông có thể tiếp cận trong chính xác 1 lần di chuyển được hiển thị bằng các mảnh màu đỏ
  (ngoài động cơ 3, không thể di chuyển)

Tỷ lệ nào của bảng có thể đạt được N-mover nhất định?

Đầu vào

• Một số nguyên dương N

Đầu ra

• Tỷ lệ của bảng mà N-mover có thể đạt được
• Đây là một số từ 0 đến 1 (bao gồm cả)
• Đối với thử thách này, đầu ra dưới dạng phân số ở mức thấp nhất, như 1/4, được cho phép

Vì vậy, đối với đầu vào 10, cả hai 1/2và 0.5là đầu ra chấp nhận được. Đầu ra dưới dạng tử số và mẫu số riêng biệt cũng được chấp nhận, bao gồm các ngôn ngữ hỗ trợ không trôi nổi cũng như phân số. Ví dụ, 1 2hoặc [1, 2].

Đối với các đầu ra số nguyên (0 và 1), bất kỳ định dạng nào sau đây là các định dạng có thể chấp nhận:

• 0: 0, 0.0, 0/1, 0 1,[0, 1]
• 1: 1, 1.0, 1/1, 1 1,[1, 1]

Chấm điểm

Đây là mã golf. Điểm số là độ dài của mã tính bằng byte. Đối với mỗi ngôn ngữ, mã ngắn nhất sẽ thắng.

Các trường hợp thử nghiệm

Trong định dạng 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 byte

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)

Hãy thử trực tuyến!

-4 byte cảm ơn @Arnauld!

Cách tiếp cận ban đầu, 125 byte

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

Hãy thử trực tuyến!

Lấy cảm hứng từ video Pi ẩn trong các quy tắc chính của 3Blue1Brown.

Với mỗi thừa số nguyên tố $p^n$ trong hệ số của số, hãy tính $f(p^n)$ :

• Nếu $n$ là số lẻ và $p\equiv 3\text{ (mod 4)}$ - $f(p^n)=0$ . Vì không có nơi nào để đi.
• Nếu $n$ là chẵn và $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$

Nhân tất cả các giá trị hàm, chúng ta có.

Cập nhật

Nhờ nỗ lực của những người đóng góp từ Math.SE, thuật toán hiện được hỗ trợ bởi một bằng chứng

Toán học, 80 byte

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

Mã này chủ yếu dựa vào một định lý toán học. Ý tưởng cơ bản là mã yêu cầu mật độ của một mạng được đưa ra một số bộ tạo.

Chính xác hơn, chúng tôi được cung cấp một số tập hợp các vectơ - cụ thể là những vectơ có độ dài bình phương là N - và được yêu cầu tính mật độ của tập hợp các tổng có thể có của các vectơ này, so với tất cả các vectơ nguyên. Toán học khi chơi là chúng ta luôn có thể tìm thấy hai vectơ (và đối diện của chúng) "tạo ra" (tức là tổng của chúng) cùng tập hợp với bộ sưu tập ban đầu. LatticeReduce làm chính xác điều đó.

Nếu bạn chỉ có hai vectơ, bạn có thể tưởng tượng vẽ một hình bình hành giống hệt nhau được căn giữa tại mỗi điểm có thể tiếp cận, nhưng độ dài cạnh của nó là các vectơ đã cho, sao cho mặt phẳng được lát hoàn toàn bởi các hình bình hành này. (Ví dụ, hãy tưởng tượng một mạng có hình dạng "kim cương" cho n = 2). Diện tích của mỗi hình bình hành là yếu tố quyết định của hai vectơ tạo. Tỷ lệ mong muốn của mặt phẳng là đối ứng của khu vực này, vì mỗi hình bình hành chỉ có một điểm có thể tiếp cận trong đó.

Mã này là một triển khai khá đơn giản: Tạo các vectơ, sử dụng LatticeReduce, lấy định thức, sau đó lấy đối ứng. (Tuy nhiên, nó có thể được chơi tốt hơn)

Sạch , 189 185 172 171 byte

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)

Hãy thử trực tuyến!

Tìm mọi vị trí có thể tiếp cận trong nô vuông có cạnh dài trên góc gốc trong góc phần tư thứ nhất, sau đó chia n^2cho để lấy phần của tất cả các ô có thể tiếp cận.

Điều này hoạt động vì:

• Toàn bộ mặt phẳng có thể tiếp cận có thể được coi là bản sao chồng chéo của nhình vuông có chiều dài cạnh này, mỗi góc được đặt trên một điểm có thể tiếp cận từ điểm gốc như thể nó là điểm gốc.
• Tất cả các chuyển động đến trong nhóm bốn với các dấu hiệu ++ +- -+ --, cho phép lát gạch chồng chéo được mở rộng thông qua ba góc phần tư khác bằng cách phản chiếu và xoay.

Võng mạc 0.8.2 , 126 82 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

.+
$*

Chuyển đổi sang unary.

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

Liên tục chia theo các yếu tố chính của hình thức 4k+1.

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

Nếu kết quả không phải là một hình vuông hay hai lần một hình vuông thì kết quả bằng không.

11+
1/$.&

Tính toán đối ứng dưới dạng phân số thập phân.

Regex (ECMAScript, đối ứng ra), 256 163 157 94 83 82 byte

-93 byte nhờ vào Neil
-6 byte một lần nữa nhờ Neil
-63 byte bằng cách thực hiện phép chia mà không thu được số chia
-11 byte nhờ vào byte chia tùy chọn đồng thời và căn bậc
1 của byte bằng cách di chuyển điều kiện kết thúc khớp và trả lại giá trị bắt vào vòng lặp như là một thay thế thứ hai, nhờ Grimy

Điều này sử dụng toán học tương tự như câu trả lời JavaScript của Shieru Asakoto .

Các đầu vào là đơn nguyên. Vì regex thuần chỉ có thể trả về dưới dạng đầu ra một chuỗi con từ đầu vào (nghĩa là số tự nhiên nhỏ hơn hoặc bằng đầu vào) hoặc "không khớp", regex này trả về tỷ lệ nghịch của tỷ lệ của bảng mà N-mover có thể đạt được. Vì nghịch đảo của 0 là vô cùng, nó trả về "không khớp" trong trường hợp đó.

CẢNH BÁO SPOILER : Đối với căn bậc hai, regex này sử dụng một biến thể của thuật toán nhân tổng quát, không rõ ràng và có thể là một câu đố bổ ích để tự mình giải quyết. Để biết thêm thông tin, hãy xem giải thích cho dạng thuật toán này trong Tìm số 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

Hãy thử trực tuyến!
Hãy thử trực tuyến! (chỉ các trường hợp thử nghiệm)

^
(?=
    (                          # 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 + (? *), Đầu ra đối ứng), 207 138 132 byte

Bị lỗi thời bằng cách thực hiện phép chia mà không bắt được số chia (tức là giống hệt như trên).

Regex (ECMAScript 2018, đầu ra đối ứng), 212 140 134 byte

Bị lỗi thời bằng cách thực hiện phép chia mà không bắt được số chia (tức là giống hệt như trên).

Regex (ECMAScript, đầu ra phân số), 80 byte

Trong phiên bản này, tử số được trả về \10(không nếu không đặt / NPCG) và mẫu số trong \7.

Không giống như phiên bản đầu ra đối ứng:

• Đầu vào bằng 0 không được xử lý chính xác (nó trả về "không khớp" giống như phiên bản đó, nhưng không giống như nó, không tương ứng với giá trị đầu ra bằng 0).
• Nếu thử nghiệm hình vuông hoàn hảo thất bại, nó không quay lại vòng lặp phân chia, vì vậy phiên bản này hiệu quả hơn trong thời gian thực hiện.

Nhược điểm lớn của một đặc tả đầu ra như thế này là nó không có trong chính chương trình.

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

Hãy thử trực tuyến!
Hãy thử trực tuyến! (chỉ các trường hợp thử nghiệm)

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

Thạch ,  25  24 byte

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

Một liên kết đơn âm sử dụng các yếu tố chính.

Hãy thử trực tuyến!

Làm sao?

Æ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 trước đó là:

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

Chương trình đầy đủ vũ phu ; mã có thể dài hơn tuyến nguyên tố chính (tôi có thể thử sau).

Hãy thử trực tuyến!

Bắt đầu bằng cách tạo các bước di chuyển duy nhất sau đó tọa độ di chuyển liên tục từ tất cả các vị trí đạt được tích lũy kết quả, lấy modulo ncủa từng tọa độ (để giới hạn ntheo ngóc phần tư) và giữ các điểm khác biệt cho đến khi đạt được điểm cố định; rồi cuối cùng chia số đếm chon^2

05AB1E , 27 26 25 byte

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

Câu trả lời JavaScript của @ShieruAsakoto , vì vậy hãy đảm bảo nâng cao anh ấy!

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Ó                   # 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 Extended) , 21 byte

Chương trình này sử dụng các yếu tố chính. Tôi mang ơn Adám, dzaima, H.PWiz, J.Sallé và ngn. APL Orchard là một nơi tuyệt vời để học APL và họ luôn sẵn lòng giúp đỡ

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

Hãy thử trực tuyến!

Ungolfing

Phần 2 của mã này giống như trong phiên bản Unicode của Dyalog bên dưới, và vì vậy trong phần giải thích này, tôi sẽ tập trung vào ⍭*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 byte ^SBCS

Chương trình này sử dụng các yếu tố chính. Học được một vài thủ thuật trong khi viết bài này và tôi vô cùng biết ơn Adám, dzaima, H.PWiz, J.Sallé và ngn. APL Orchard là một nơi tuyệt vời để học APL và họ luôn sẵn lòng giúp đỡ (hoặc bài đăng này sẽ không bao giờ được đưa ra khỏi mặt đất :)

Chỉnh sửa: -1 byte từ ngn. -2 byte từ Adám và -2 thêm từ ngn. -1 byte từ ngn.

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

Hãy thử trực tuyến!

Ungolfing

Đây là một chương trình gồm hai phần:

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.