Tek hamle

Tahta, sınırsız bir satranç tahtasında olduğu gibi sonsuz bir 2 boyutlu kare ızgaradır. N değeri olan bir parça (bir N-taşıyıcı ), tam olarak N'in karekökü olan karesi olan karesi olan herhangi bir kareye hareket edebilir (Euclid uzaklığı merkezden merkeze ölçülür).

Örneğin:

• 1 taşıyıcı, yatay veya dikey olarak bitişik olan herhangi bir kareye hareket edebilir
• 2 hareketli, çapraz olarak bitişik olan herhangi bir kareye hareket edebilir
• 5 oyunculu bir satranç şövalyesi gibi hareket ediyor

Tüm N-hareketlerinin hareket edemediğini unutmayın. 3 hamle mevcut kareden asla çıkamaz çünkü tahtadaki karelerin hiçbiri tam karenin 3 kökünden değildir.

Birden çok hamle

Tekrar tekrar hareket etmesine izin verilirse, bazı parçalar tahtadaki herhangi bir kareye ulaşabilir. Örneğin, 1 taşıyıcı ve 5 taşıyıcı da bunu yapabilir. 2 taşıyıcı, yalnızca çapraz şekilde hareket edebilir ve karelerin yalnızca yarısına erişebilir. 3-taşıyıcı gibi hareket edemeyen bir parça hiçbir kareye ulaşamaz (hareket olmazsa başlangıç ​​karesi "ulaşıldı" olarak sayılmaz) .

Görüntüler hangi karelere ulaşılabileceğini göstermektedir. Vurgulu hakkında daha fazla bilgi. Daha büyük resim için tıklayınız.

• 1 veya daha fazla hareketle ulaşılabilen kareler siyahla işaretlenmiştir.
• Tam olarak 1 harekette ulaşılabilen kareler kırmızı parçalarla gösterilir
  (hareket etmeyen 3 hareketli hariç)

Bir N-mover tahtasının hangi oranına ulaşabilir?

Giriş

• Pozitif bir tamsayı N

Çıktı

• Bir N-taşıyıcısının erişebileceği kartın oranı
• Bu 0 ile 1 arasında bir sayıdır (her ikisi de dahil)
• Bu zorluk için, 1/4 gibi en düşük terimlerden oluşan bir kesir olarak çıktı alınmasına izin verilir.

Bu nedenle giriş için 10, her ikisi de 1/2ve 0.5kabul edilebilir çıkışlarıdır. Yüzenleri ve kesirleri desteklemeyen dilleri içerecek şekilde ayrı pay ve payda olarak çıkış da kabul edilebilir. Örneğin, 1 2ya da [1, 2].

Tamsayı çıkışları (0 ve 1) için, aşağıdakilerden herhangi biri kabul edilebilir formatlardır:

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

puanlama

Bu kod golfü. Skor, bayt cinsinden kodun uzunluğu. Her dil için en kısa kod kazanır.

Test durumları

Biçiminde 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 bayt

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)

Çevrimiçi deneyin!

-4 bayt teşekkürler @Arnauld!

Orijinal yaklaşım, 125 bayt

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

Çevrimiçi deneyin!

Pi videosundan ilham alarak 3Blue1Brown tarafından birincil düzenliliklerde saklanıyor.

Her ana faktör, $p^n$ sayısı, hesaplamak ve çarpanlara olarak $f(p^n)$ :

• Eğer $n$ tek ve bir $p\equiv 3\text{ (mod 4)}$ - $f(p^n)=0$ . Çünkü gidecek bir yer yok.
• Eğer $n$ düz ve bir $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$

Tüm bu fonksiyon değerlerini çarpın, işte oradayız.

Güncelleme

Math.SE'den katkıda bulunanların çabaları sayesinde, algoritma şimdi bir ispatla destekleniyor

Mathematica, 80 bayt

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

Bu kod çoğunlukla matematik teoremine dayanır. Temel fikir, kodun, bazı üretici setler verilen bir kafesin yoğunluğunu istediğidir.

Daha doğrusu, bize bazı uzunluklar verilmiştir - yani, uzunluğu karesi N olanlara - ve tüm tamsayı vektörlerine kıyasla bu vektörlerin olası toplamlarının yoğunluğunu hesaplamaları istenmiştir. Oyunda matematik, her zaman orijinal koleksiyonu ile aynı kümeyi "üreten" (yani toplamları) olan iki vektörü (ve tersini) bulabiliriz. LatticeReduce tam olarak bunu yapıyor.

Eğer sadece iki vektörünüz varsa, ulaşılabilir her noktada merkezlenmiş aynı bir paralelkenar çizmeyi, ancak uç uzunluklarının verilen vektörler olduğunu, düzlemin bu paralelkenarlar tarafından tamamen döşenmesini hayal edebilirsiniz. (Örneğin, n = 2 için "elmas" şekillerinin bir kafesini düşünün). Her bir paralelkenarın alanı iki üretici vektörün belirleyicisidir. Uçağın istenen oranı, bu alanın tersidir, çünkü her bir paralelkenarın içinde sadece bir ulaşılabilir nokta vardır.

Kod oldukça basit bir uygulamadır: Vektörleri oluşturun, LatticeReduce kullanın, determinantı alın, sonra karşılıklı alın. (Yine de, muhtemelen daha iyi golf olabilir)

Temiz , 189 185 172 171 bayt

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)

Çevrimiçi deneyin!

nİlk kadranda orijin üzerinde köşeli köşede bulunan her pozisyonu bulur , daha sonra n^2tüm hücrelerin bir kısmına ulaşılabilmesi için bölünür .

Bu çalışır çünkü:

• Ulaşılabilir düzlemin tamamı n, her biri orijinden sanki oradan bir ulaşılabilir noktaya köşeye sıkıştırılan bu uzunluktaki karenin örtüşen kopyaları olarak düşünülebilir .
• Tüm hareketler işaretli dörtlü gruplar halinde gelir ++ +- -+ --ve üst üste binen döşemenin yansıtma ve döndürme ile diğer üç kadran boyunca uzatılmasını sağlar.

Retina 0.8.2 , 126 82 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

.+
$*

Birliğe dönüştür.

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

Tekrar tekrar formun ana faktörlerine bölün 4k+1.

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

Sonuç ne kare ne de iki kere kare ise sonuç sıfırdır.

11+
1/$.&

Karşılıklı değeri ondalık kesir olarak hesaplayın.

Regex (ECMAScript, karşılıklı çıktı), 256 163 157 94 83 82 bayt

-93 bayt Neil sayesinde
-6 bayt Neil'a tekrar teşekkürler
-63 bayt böleni yakalamadan bölme yaparak
-11 bayt -Grimy'nin eşzamanlı isteğe bağlı bölüm-by- byte ve karekök- byte-bit eşleşme koşulu taşıyarak -11 bayt sayesinde
ve Grimy sayesinde değer yakalamayı ikinci alternatif olarak döngünün içine döndür

Bu Shieru Asakoto'nun JavaScript cevabıyla aynı matematiği kullanır .

Giriş birleşik. Saf bir regex yalnızca girdiden bir alt dize çıktı olarak döndüğü için (yani girişe eşit veya daha az doğal bir sayı) veya "eşleşme yok", bu regex, N-taşıyıcısının verdiği oranın tersini döndürür. ulaşabilir. 0'ın karşılıklı olması sonsuz olduğundan, bu durumda "eşleşme yok" döndürür.

SPOILER UYARI : Karekök için, bu regex, açık olmayan ve kendi başınıza çalışmanız için ödüllendirici bir bulmaca olabilecek, genelleştirilmiş çarpma algoritmasının bir çeşidini kullanır. Daha fazla bilgi için, Bulunacak bir Rocco numarası bölümündeki algoritmanın bu formu için bir açıklamaya bakın .

$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

Çevrimiçi deneyin!
Çevrimiçi deneyin! (sadece test durumları)

^
(?=
    (                          # 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 + (? *), Karşılıklı çıktı), 207 138 132 bayt

Böleni yakalamadan bölme yaparak eskimiş (yani şimdi yukarıdakilerle aynıdır).

Regex (ECMAScript 2018, karşılıklı çıktı), 212 140 134 bayt

Böleni yakalamadan bölme yaparak eskimiş (yani şimdi yukarıdakilerle aynıdır).

Regex (ECMAScript, kesir çıkışı), 80 bayt

Bu versiyonda, pay \10( içinde unset / NPCG ise sıfır) ve içinde payda döndürülür \7.

Karşılıklı çıktı versiyonundan farklı olarak:

• Sıfır girişi doğru şekilde ele alınmaz (tıpkı bu sürümde olduğu gibi "eşleşme yok" döndürür, ancak aksine, sıfır çıkış değerine karşılık gelmez).
• Mükemmel kare testi başarısız olursa, bölme döngüsüne geri dönmez, bu nedenle bu sürüm yürütme süresinde daha verimlidir.

Bunun gibi bir çıktı belirtiminin büyük dezavantajı programın kendisinde bulunmamasıdır.

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

Çevrimiçi deneyin!
Çevrimiçi deneyin! (sadece test durumları)

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

Jöle ,  25  24 bayt

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

Asal faktör yolunu kullanan bir monadik bağlantı.

Çevrimiçi deneyin!

Nasıl?

Æ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

Önceki 25:

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

Tam program kaba forcer ; belki ana faktör yolundan daha uzun kod (daha sonra deneyebilirim).

Çevrimiçi deneyin!

Modulo alarak, arka arkaya sonra sonuçlar biriken bütün ulaştığı konumlarından hareket koordinatları olarak tek hareket oluşturarak başlatır nher biri (bir kısıtlamak için koordinat ntarafından nkadran) ve sabit bir noktaya ulaşılıncaya kadar belirgin olanlar tutulması; sonra nihayet sayımı bölern^2

05AB1E , 27 26 25 bayt

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

Port @ShieruAsakoto 'ın JavaScript cevap , çok emin onu da upvote olun!

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

Ó                   # 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 Genişletilmiş) , 21 bayt

Bu program ana faktör yolunu kullanır. Adám, dzaima, H.PWiz, J.Sallé ve ngn. APL Orchard APL öğrenmek için harika bir yer ve her zaman yardım etmeye istekli

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

Çevrimiçi deneyin!

Ungolfing

Bu kodun 2. Bölümü, aşağıdaki Dyalog Unicode sürümündeki ile aynıdır ve bu açıklamada, aşağıdakilere odaklanacağım: ⍭*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 bayt ^SBCS

Bu program ana faktör yolunu kullanır. Bunu yazarken birkaç püf noktası öğrendim ve Adám, dzaima, H.PWiz, J.Sallé ve ngn'e derinden borçluyum. APL Orchard APL öğrenmek için harika bir yer ve her zaman yardım etmeye istekli (ya da bu yazı asla yerden olmazdı :)

Düzenleme: ngn'den -1 bayt. Adám'dan -2 bayt ve ngn'den -2 bayt. Ngn'den -1 bayt.

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

Çevrimiçi deneyin!

Ungolfing

Bu iki bölümden oluşan bir programdır:

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.