단일 동작

보드는 무한 체스 보드와 같은 무한 2 차원 사각형 격자입니다. 값이 N ( N-mover ) 인 조각 은 현재 사각형에서 정확히 N의 제곱근 거리 인 모든 사각형으로 이동할 수 있습니다 (유클리드 거리 측정 중심).

예를 들면 다음과 같습니다.

• 1-Mover는 수평 또는 수직으로 인접한 사각형으로 이동할 수 있습니다
• 2 개의 발동기는 대각선으로 인접한 사각형으로 이동할 수 있습니다
• 5 명의 발동기가 체스 기사처럼 움직입니다.

모든 N- 이동자가 움직일 수있는 것은 아닙니다. 보드의 사각형 중 어느 것도 현재 사각형에서 정확히 3의 거리를 가지지 않기 때문에 3 발동기는 현재 사각형을 벗어날 수 없습니다.

여러 동작

반복적으로 움직일 수 있으면 일부 조각이 보드의 모든 사각형에 도달 할 수 있습니다. 예를 들어, 1-Mover 및 5-Mover는 모두이 작업을 수행 할 수 있습니다. 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

자바 스크립트 (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)

온라인으로 사용해보십시오!

@Arnauld -4 바이트 감사합니다!

원래 접근 방식, 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의 주요 규칙 에 숨어 있는 비디오 Pi에서 영감을 얻었 습니다.

$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를 사용하고, 결정자를 취한 다음 역수를 취하십시오. (아마도 더 나은 골프가 될 수 있습니다)

면도 , 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)

온라인으로 사용해보십시오!

n1 사분면의 원점에서 모퉁이에 있는 -side-length 사각형에 도달 가능한 모든 위치를 찾은 다음 n^2모든 셀의 일부에 도달 할 수 있도록 나눕니다 .

이것은 다음과 같은 이유로 작동합니다.

• 도달 가능한 전체 평면은이 측면 n길이 정사각형 의 겹치는 사본으로 간주 될 수 있으며 각 원점은 원점 에서처럼 원점에서 도달 가능한 지점에 코너링됩니다.
• 모든 움직임은 표시가있는 4 개의 그룹으로 이루어 ++ +- -+ --지며, 중첩 된 타일링은 미러링 및 회전에 의해 다른 3 사분면을 통해 확장 될 수 있습니다.

레티 나 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

결과가 제곱도 아니고 제곱도 아닌 경우 결과는 0입니다.

11+
1/$.&

역수를 소수로 계산합니다.

정규식 (ECMAScript를, 아웃 왕복) 256 163 157 94 83 82 바이트

-93은 바이트 닐 덕분에
-6 바이트 닐에 다시 감사
-63 제수를 캡처하지 않고 분할을 수행하여 바이트
-11 덕분 바이트 검댕으로 더럽혀진의 동시 옵션 부문 별 일정 및 제곱근
최종 일치 조건을 이동하여 -1 바이트를 Grimy 덕분에 두 번째 대안으로 루프로의 값 캡처 반환

이것은 Shieru Asakoto의 JavaScript answer 와 동일한 수학을 사용합니다 .

입력이 단항입니다. 순수 정규 표현식은 입력에서 하위 문자열을 출력으로 만 리턴 할 수 있기 때문에 (즉, 입력보다 작거나 같은 자연수) "일치하지 않음"이므로이 정규 표현식은 N-Mover 인 보드 비율의 역수를 리턴합니다. 도달 할 수 있습니다. 역수 0은 무한대이므로이 경우 "일치하지 않음"을 반환합니다.

SPOILER WARNING : 제곱근의 경우,이 정규식은 일반화 곱셈 알고리즘의 변형을 사용합니다.이 곱셈은 명백하지 않으며 스스로 해결할 수있는 보람있는 퍼즐 일 수 있습니다. 자세한 정보 는 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(unset / NPCG 인 경우 0) 에, 분모는에 반환 됩니다 \7.

상호 출력 버전과 달리 :

• 0의 입력은 올바르게 처리되지 않습니다 (해당 버전과 마찬가지로 "일치하지 않음"을 반환하지만, 출력 값이 0 인 것과는 달리).
• 완벽한 제곱 테스트가 실패하면 분할 루프로 역 추적되지 않으므로이 버전은 실행 시간이 더 효율적입니다.

이와 같은 출력 사양의 큰 단점은 프로그램 자체에 포함되어 있지 않다는 것입니다.

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

소인수 경로를 사용하는 모나드 링크.

온라인으로 사용해보십시오!

어떻게?

Æ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각 (AN을 제한하도록 조정을 n하여 n사분면)과 고정 점에 도달 할 때까지 별개로 유지하는 것과; 마지막으로 카운트를 나눕니다.n^2

05AB1E , 27 26 25 바이트

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

@ShieruAsakoto 의 JavaScript 답변 포트 , 그래서 그를 찬성 해야합니다!

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

Ó                   # 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 바이트

이 프로그램은 소인수 경로를 사용합니다. 나는 Adám, dzaima, H.PWiz, J.Sallé 및 ngn에게 빚을졌습니다. APL 과수원 은 APL 을 배우기에 좋은 장소이며 항상 기꺼이 도와줍니다.

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

온라인으로 사용해보십시오!

언 골핑

이 코드의 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

APL (Dyalog Unicode) , 41 40 36 35 바이트 ^SBCS

이 프로그램은 소인수 경로를 사용합니다. 이 글을 쓰는 동안 몇 가지 요령을 배웠고 Adám, dzaima, H.PWiz, J.Sallé 및 ngn에 깊이 빚졌습니다. APL 과수원 은 APL 을 배우기에 좋은 곳이며 항상 기꺼이 도와줍니다 (또는이 게시물은 결코 시작되지 않았을 것입니다 :)

편집 : ngn에서 -1 바이트. Adám에서 -2 바이트, ngn에서 -2 바이트 ngn에서 -1 바이트

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

온라인으로 사용해보십시오!

언 골핑

이것은 두 부분으로 된 프로그램입니다.

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.