Einzelne Züge

Das Brett ist ein unendliches 2-dimensionales quadratisches Gitter, wie ein unbegrenztes Schachbrett. Ein Teil mit dem Wert N (ein N-Mover ) kann sich zu einem beliebigen Quadrat bewegen, das genau die Quadratwurzel von N von seinem aktuellen Quadrat entfernt ist (euklidischer Abstand von Mitte zu Mitte gemessen).

Zum Beispiel:

• Ein 1-Mover kann sich auf ein beliebiges Feld bewegen, das horizontal oder vertikal angrenzt
• Ein 2-Mover kann sich auf jedes diagonal benachbarte Quadrat bewegen
• Ein 5-Mover bewegt sich wie ein Schachritter

Beachten Sie, dass sich nicht alle N-Mover bewegen können. Ein 3-Mover kann sein aktuelles Quadrat niemals verlassen, da keines der Quadrate auf dem Brett einen Abstand von genau Wurzel 3 zum aktuellen Quadrat hat.

Mehrere Züge

Wenn man sich wiederholt bewegen darf, können einige Steine ​​ein beliebiges Feld auf dem Brett erreichen. Zum Beispiel können sowohl ein 1-Mover als auch ein 5-Mover dies tun. Ein 2-Mover kann sich nur diagonal bewegen und nur die Hälfte der Quadrate erreichen. Eine Figur, die sich nicht bewegen kann, wie ein 3-Mover, kann keines der Quadrate erreichen (das Startquadrat wird nicht als "erreicht" gezählt, wenn keine Bewegung stattfindet) .

Die Bilder zeigen, welche Quadrate erreicht werden können. Weitere Details zum Hover. Klicken für größeres Bild.

• Quadrate, die in einem oder mehreren Zügen erreicht werden können, sind schwarz markiert
• Felder, die in genau einem Zug erreicht werden können, werden durch rote Steine ​​dargestellt
  (außer dem 3-Mover, der sich nicht bewegen kann).

Welchen Anteil des Boards kann ein bestimmter N-Mover erreichen?

Eingang

• Eine positive ganze Zahl N

Ausgabe

• Der Anteil des Boards, den ein N-Mover erreichen kann
• Dies ist eine Zahl von 0 bis 1 (beide inklusive)
• Für diese Herausforderung ist die Ausgabe als Bruch in niedrigsten Ausdrücken wie 1/4 zulässig

Für die Eingabe 10sind also beide 1/2und 0.5akzeptable Ausgaben. Die Ausgabe als separater Zähler und Nenner ist ebenfalls zulässig, um Sprachen einzuschließen, die weder Gleitkomma noch Brüche unterstützen. Zum Beispiel 1 2oder [1, 2].

Für die Ganzzahlausgaben (0 und 1) sind folgende Formate zulässig:

• Für 0: 0, 0.0, 0/1, 0 1,[0, 1]
• 1: 1, 1.0, 1/1, 1 1,[1, 1]

Wertung

Das ist Code Golf. Die Punktzahl ist die Länge des Codes in Bytes. Für jede Sprache gewinnt der kürzeste Code.

Testfälle

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

Probieren Sie es online!

-4 byte danke @Arnauld!

Ursprünglicher Ansatz, 125 Bytes

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

Probieren Sie es online!

Inspiriert von dem Video Pi, das sich in erstklassigen Regelmäßigkeiten von 3Blue1Brown versteckt.

Berechnen Sie für jeden Primfaktor in der Faktorisierung der Zahl :$p^n$$f(p^n)$

• Wenn ungerade ist und - . Weil es keinen Ort gibt, an den man gehen kann.$n$$p\equiv 3\text{ (mod 4)}$$f(p^n)=0$
• Wenn ist und - .$n$$p\equiv 3\text{ (mod 4)}$$f(p^n)=\frac{1}{p^n}$
• Wenn - .$p=2$$f(2^n)=\frac{1}{2^n}$
• Wenn - .$p\equiv 1\text{ (mod 4)}$$f(p^n)=1$

Multiplizieren Sie all diese Funktionswerte.

Aktualisieren

Dank der Bemühungen von Mitarbeitern von Math.SE wird der Algorithmus jetzt durch einen Beweis untermauert

Mathematica, 80 Bytes

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

Dieser Code beruht hauptsächlich auf einem mathematischen Theorem. Die Grundidee ist, dass der Code die Dichte eines Gitters bei einem bestimmten Generatorsatz abfragt.

Genauer gesagt, wir erhalten eine Sammlung von Vektoren - nämlich diejenigen, deren Länge im Quadrat N ist - und werden gebeten, die Dichte der Menge möglicher Summen dieser Vektoren im Vergleich zu allen ganzzahligen Vektoren zu berechnen. Die Mathematik geht davon aus, dass wir immer zwei Vektoren (und deren Gegenteil) finden können, die die gleiche Menge wie die ursprüngliche Sammlung "erzeugen" (dh deren Summen sind). LatticeReduce macht genau das.

Wenn Sie nur zwei Vektoren haben, können Sie sich vorstellen, ein identisches Parallelogramm zu zeichnen, das an jedem erreichbaren Punkt zentriert ist, dessen Kantenlänge jedoch die angegebenen Vektoren sind, sodass die Ebene durch diese Parallelogramme vollständig gekachelt wird. (Stellen Sie sich zum Beispiel ein Gitter mit "Diamant" -Formen für n = 2 vor). Die Fläche jedes Parallelogramms ist die Determinante der beiden erzeugenden Vektoren. Der gewünschte Anteil der Ebene ist der Kehrwert dieses Bereichs, da jedes Parallelogramm nur einen erreichbaren Punkt enthält.

Der Code ist eine recht einfache Implementierung: Generieren Sie die Vektoren, verwenden Sie LatticeReduce, nehmen Sie die Determinante und nehmen Sie dann den Kehrwert. (Es kann aber wahrscheinlich besser Golf gespielt werden)

Sauber , 189 185 172 171 Bytes

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)

Probieren Sie es online!

Findet jede Position, die auf dem nQuadrat mit der Seitenlänge in der Ecke des Ursprungs im ersten Quadranten erreichbar ist, und dividiert dann durch n^2, um den Teil aller Zellen zu ermitteln, die erreichbar sind.

Das funktioniert, weil:

• Die gesamte erreichbare Ebene kann als überlappende Kopie dieses nQuadrats mit Seitenlänge betrachtet werden. Jedes Quadrat ist an einem erreichbaren Punkt vom Ursprung aus in einer Ecke angeordnet, als wäre es der Ursprung.
• Alle Bewegungen werden in Vierer-Gruppen mit Vorzeichen ausgeführt ++ +- -+ --, sodass die überlappenden Kacheln durch Spiegeln und Drehen auf die anderen drei Quadranten ausgedehnt werden können.

Retina 0.8.2 , 126 82 Bytes

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

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.+
$*

In Unary konvertieren.

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

Wiederholt durch Primfaktoren der Form teilen 4k+1.

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

Wenn das Ergebnis weder ein Quadrat noch ein doppeltes Quadrat ist, ist das Ergebnis Null.

11+
1/$.&

Berechnen Sie den Kehrwert als Dezimalbruch.

Regex (ECMAScript, wechselseitig aus), 256 163 157 94 83 82 Bytes

-93 Bytes dank Neil
-6 Bytes dank Neil
-63 Bytes durch Division ohne Erfassung des Divisors
-11 Bytes dank Grimys simultaner optionaler Division durch Konstante und Quadratwurzel
-1 Bytes durch Verschieben der End-Match-Bedingung und dank Grimy als zweite Alternative die Erfassung von Werten in die Schleife zurückgeben

Dies verwendet die gleiche Mathematik wie die JavaScript-Antwort von Shieru Asakoto .

Die Eingabe ist unär. Da ein reiner Regex nur einen Teilstring vom Eingang (dh eine natürliche Zahl, die kleiner oder gleich dem Eingang ist) oder "keine Übereinstimmung" als Ausgabe zurückgeben kann, gibt dieser Regex den Kehrwert des Anteils der Karte zurück, den ein N-Mover hat kann erreichen. Da der Kehrwert von 0 unendlich ist, wird in diesem Fall "keine Übereinstimmung" zurückgegeben.

SPOILER-WARNUNG : Für die Quadratwurzel verwendet dieser Regex eine Variante des verallgemeinerten Multiplikationsalgorithmus. Dies ist nicht offensichtlich und kann ein lohnendes Rätsel sein, das Sie selbst lösen können . Weitere Informationen finden Sie in der Erklärung zu dieser Form des Algorithmus unter Suchen einer Rocco-Nummer .

$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

Probieren Sie es online!
Probieren Sie es online! (nur die Testfälle)

^
(?=
    (                          # 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 + (? *), Wechselseitige Ausgabe), 207 138 132 Bytes

Wird durch Division überholt, ohne den Divisor zu erfassen (dh ist jetzt identisch mit dem oben genannten).

Regex (ECMAScript 2018, wechselseitige Ausgabe), 212 140 134 Bytes

Wird durch Division überholt, ohne den Divisor zu erfassen (dh ist jetzt identisch mit dem oben genannten).

Regex (ECMAScript, Bruchausgabe), 80 Bytes

In dieser Version wird der Zähler in \10(Null, wenn nicht gesetzt / NPCG) und der Nenner in zurückgegeben \7.

Im Gegensatz zur reziproken Ausgabeversion:

• Eine Eingabe von Null wird nicht korrekt behandelt (sie gibt genau wie diese Version "keine Übereinstimmung" zurück, entspricht aber im Gegensatz dazu keinem Ausgabewert von Null).
• Wenn der perfekte Quadrattest fehlschlägt, wird nicht in die Teilungsschleife zurückgespult, sodass diese Version effizienter in der Ausführungszeit ist.

Der große Nachteil einer solchen Ausgabespezifikation ist, dass sie nicht im Programm selbst enthalten ist.

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

Probieren Sie es online!
Probieren Sie es online! (nur die Testfälle)

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

Jelly ,  25  24 Bytes

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

Eine monadische Verbindung unter Verwendung der Primfaktor-Route.

Probieren Sie es online!

Wie?

Æ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

Vorherige 25 war:

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

Volles Programm Brute Forcer ; Möglicherweise längerer Code als die Route mit dem Primfaktor (ich könnte es später versuchen).

Probieren Sie es online!

Beginnt , indem das Herstellen der einzelnen Bewegungen als Koordinaten dann wiederholt sich von allen Stellen erreicht die Ergebnisse akkumuliert, wobei modulo njeder Koordinate (zu beschränken , um eine ndurch nQuadrant) und halten solche , die verschieden sind , bis ein fester Punkt erreicht wird; dann dividiert schließlich die Zählung durchn^2

05AB1E , 27 26 25 Bytes

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

Port von @ShieruAsakotos JavaScript-Antwort , also stelle sicher, dass du ihn auch positiv bewertest!

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Dieses Programm benutzt die Primfaktor Route. Ich bin Adám, dzaima, H.PWiz, J.Sallé und ngn zu Dank verpflichtet. Der APL-Obstgarten ist ein großartiger Ort, um APL zu lernen, und sie sind immer bereit zu helfen

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

Probieren Sie es online!

Ungolfing

Teil 2 dieses Codes ist derselbe wie in der folgenden Dyalog Unicode-Version, und deshalb werde ich mich in dieser Erläuterung darauf konzentrieren ⍭*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

Dieses Programm benutzt die Primfaktor Route. Ich habe beim Schreiben ein paar Tricks gelernt und bin Adám, dzaima, H.PWiz, J.Sallé und ngn zutiefst verbunden. Der APL-Obstgarten ist ein großartiger Ort, um APL zu lernen, und sie sind immer bereit zu helfen (andernfalls wäre dieser Beitrag niemals in Gang gekommen :)

Edit: -1 Byte von ngn. -2 Bytes von Adám und -2 weitere von ngn. -1 Byte von ngn.

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

Probieren Sie es online!

Ungolfing

Dies ist ein Programm in zwei Teilen:

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.