如果最接近的其他素数小于素数，则素数是弱的。如果有平局，则素数并不弱。

例如73是弱素数，因为71是素数，而75是复合数。

任务

编写一些计算机代码，当输入大于2的质数时，将确定它是否为弱质数。这是一个标准的决策问题，因此您应针对两种情况（例如weak和not weak）分别输出两个唯一值。

这是代码高尔夫球，因此适用标签的标准规则。

信息系统

以下是前47个弱素数：

3, 7, 13, 19, 23, 31, 43, 47, 61, 73, 83, 89, 103, 109, 113, 131, 139, 151, 167, 181, 193, 199, 229, 233, 241, 271, 283, 293, 313, 317, 337, 349, 353, 359, 383, 389, 401, 409, 421, 433, 443, 449, 463, 467, 491, 503, 509, 523, 547, 571, 577, 601, 619, 643, 647

这是弱质数的OEIS（应退货weak）OEIS A051635

这是平衡素数的OEIS（应退货not weak）OEIS A006562

这是强素数的OEIS（应退货not weak）OEIS A051634

果冻，7个字节

Æn+Æp>Ḥ

在线尝试！

说明

           See if
Æn         the next prime
  +Æp      plus the previous prime
     >Ḥ    is greater than 2n

作为奖励，改变>到 =或<分别检查平衡和强大的素数。

Mathematica，24个字节

n=NextPrime;2#+n@-#<n@#&

在NextPrime内置的可（AB？）使用喂养它负值的参数来计算以前的素数。

果冻，9 个字节

ḤÆRạÞ⁸ḊḢ>

返回1弱和0不弱或平衡（返回1为输入2）

在线尝试！

怎么样？

ḤÆRạÞ⁸ḊḢ> - Link: prime number > 2, p
Ḥ         - double -> 2*p
 ÆR       - yield primes between 2 and 2*p inclusive
     ⁸    - chain's left argument, p
    Þ     - sort by:
   ạ      -   absolute difference (i.e. distance from p)
      Ḋ   - dequeue (removes p from the list, since it has distance zero)
       Ḣ  - head (gives us the nearest, if two the smallest of the two)
        > - greater than p?

PHP，69字节

为弱素数打印一个，而不为弱素数打印任何内容

for(;!$t;$t=$d<2)for($n=$d=$argn+$i=-$i+$w^=1;$n%--$d;);echo$n<$argn;

在线尝试！

八度，93 84字节

感谢@LuisMendo和@ rahnema1节省了字节！

function r=f(x);i=j=x;do--i;until(i<1|isprime(i));do++j;until(isprime(j));r=x-i<j-x;

在线尝试！

Maxima，42个字节

f(n):=is(n-prev_prime(n)<next_prime(n)-n);

在线尝试！

MATL，13字节

qZq0)G_Yq+GE>

1如果弱，0则输出，否则。

在线尝试！

说明

q      % Implicit input, Subtract 1
Zq     % Vector of primes up to that
0)     % Get last one
G      % Push input again
_Yq    % Next prime
+      % Add
G      % Push input
E      % Multiply by 2
>      % Greater than? Implicit display

GNU APL 1.2，78个字节

∇f N
X←(R←(~R∊R∘.×R)/R←1↓⍳N×2)⍳N
(|R[X-1]-N)<|R[X+1]-N
∇

∇f N 声明一个带有参数的函数。

(~R∊R∘.×R)/R←1↓⍳N×2给出从2到参数两倍的所有素数的列表。我假设下一个质数小于原始数的两倍。如果这是不正确的，则N*2使N为平方并占用相同数量的字节（希望该字节足够大以超过下一个质数）。（请参阅Wikipedia的有关如何工作的解释）

X←(R←(...))⍳N将该列表分配给vector R（覆盖其先前的内容），N在该列表中找到原始素数的索引，然后将该索引分配给X。

|R[X-1]-N计算前一个素R数之间的差（因为包含素数，X-1th元素是之前的素数N）N，然后取绝对值（APL从右到左操作）。

|R[X+1]-N 一样，但是对于下一个素数。

(|R[X-1]-N)<|R[X+1]-N如果前一个质数比下一个质数更接近原始，则输出1，否则输出0。括号必须优先。

∇ 结束功能。

果冻，9个字节

Æp;;ÆnI</

在线尝试！

Pyth，15个字节

>-fP_ThQfPT_tQy

在这里尝试。

使用Pietu1998的算法。

Perl 6，41个字节

{[>] map ->\n{$_+n,*+n...&is-prime},1,-1}

在线尝试！

$_是该函数的参数。映射函数-> \n { $_ + n, * + n ... &is-prime }接受一个数字n并返回一个数字序列，该序列$_ + n, $_ + 2*n, ...在达到质数时结束。将此函数映射到两个数字上，1并-1生成两个序列的序列；第一个$_ + 1以第一个质数大于的结束，$_第二个$_ - 1以第一个质数小于的结束$_。 [>]用大于号运算符减少此两个元素的列表，如果第一个序列大于（即更长）则返回true。

Python 2.7-120字节

from math import*
i=lambda x:factorial(x-1)%x==x-1
def f(n,c):return 1 if i(n-c)>i(n+c) else 0 if i(n+c)>0 else f(n,c+1)

由于python没有内置的prime函数，因此我们可以使用Wilson定理来获得一个不错的短质数检查器。威尔逊定理指出，当且仅当（n-1），数字才是质数！与-1 mod（n）一致。因此，如果数字为质数，则函数i将返回1，否则为0。之后，f函数将确定从该数字开始的下一个质数在递增而不是递增时是否首先出现。如果两个递增的数字都不是素数，则仅递归地再次调用它。

一些示例I / O

f(3,1)
1
f(15,1)
0

Python 2中，122个 108 103 94 92字节

def a(n):
 r=[2];x=2
 while r[-1]<=n:x+=1;r+=[x]*all(x%i for i in r)
 return sum(r[-3:])>3*n

在线尝试！

使用Pietu的想法...然后通过打高尔夫球较短的素数列表迭代器节省了28个字节；然后再替换-3*n>0为2个>3*n（d'oh！）

正则表达式（大多数样式），47字节

^(?=(x*)(?!(x+)(\2\2x)+$)\1)x+(?!(xx+)\4+$)\1\1

在线尝试！

一元输入。输出匹配弱质数，不匹配非弱质数。适用于ECMAScript，Perl，PCRE，Python，Ruby。

说明：

令N为输入，A为最接近素数<N，B为最接近素数>N。正则表达式方法对这一挑战的主要困难在于，我们不能像B那样表示大于输入的数字。找出最小的b，使2b +1为质数，2b +1> N，确保2b +1 =B。

(?=
  (x*)              # \1 = N - b, tail = b
  (?!(x+)(\2\2x)+$) # Assert 2b + 1 is prime
  \1                # Assert b ≥ \1 (and thus 2b + 1 > N)
)

然后，请注意，我们实际上并不需要找到A。只要任何素数<N比B更接近N，N就是弱素数。

x+                  # tail iterates over integers < N
(?!(xx+)\4+$)       # assert tail is prime
\1\1                # assert tail ≥ 2 * \1 (and thus tail + B > 2N)

八度，53字节

@(n)diff(list_primes(h=nnz(primes(n))+1)(h-2:h),2)>0

在线尝试！

的JavaScript ES6，162个 154字节

根据JörgHülsermann的技巧“在一种情况下不打印任何内容 ”，节省了8个字节。?"Y":"N"以后不需要one<two

var isWeak=

a=>{p=[2];i=0;f=d=>{j=p[i];l:while(j++){for(x=0;p[x]*p[x]<=j;x++){if(j%p[x]==0){continue l}}return p[++i]=j}};while(p[i]<a+1){f()};return a*2<p[i]+p[i-2]}

[43,//true
53,//false
7901,//false
7907,//true
1299853,//true
1299869//false
].forEach(n=>{console.log(n,isWeak(n))})

05AB1E，17个字节

[<Dp#]¹[>Dp#]+¹·›

在线尝试！

使用Pietu1998的算法。

Python 3，149字节

f=lambda n,k=1,P=1:n*[0]and P%k*[k]+f(n-P%k,k+1,P*k*k)
def a(n):p=f(n);return p.index(n)in filter(lambda i:p[i]-p[i-1]<p[i+1]-p[i],range(1,len(p)-1))

在线尝试！

我正在使用从这个旧堆栈交换答案中提取的质数生成函数（顶行）。

JavaScript，98个字节

let test = _=>(o.innerHTML=f(+prime.value))
let f= 

n=>{P=n=>{for(i=n,p=1;--i>1;)p=p&&n%i};a=b=n;for(p=0;!p;P(--a));for(p=0;!p;P(++b));return n-a<b-n}

Enter Prime: <input id="prime">
<button type="button" onclick="test()">test if weak</button>
<pre id="o"></pre>

减少凝视

n=>{
   P=  // is a Prime greater than 1, result in p
       n=>{
           for(i=n,p=1;--i>1;)
               p=p&&n%i
       };

   a=b=n; // initialize lower and upper primes to n
   for(p=0;!p;P(--a)); // find lower,
   for(p=0;!p;P(++b)); // find upper,
   return n-a<b-n // is weak result
}

注意检查代码并没有检查输入的“黄金”其实是一个素数。

Braingasm，23 22字节

打印1较弱的素数和较弱的素数0。

;>0$+L[->+>2[>q[#:Q]]]

演练：

;                       Read a number to cell 0
 >0$+                   Go to cell 1 and copy the value of cell 0
     L                  Make the tape wrap around after cell 1
      [              ]  Loop:
       ->+>               Decrease cell 1 and increase cell 0
           2[       ]     Twice do:
             >              Go to the other cell
              q[   ]        If it's prime:
                #:Q         Print the current cell number and quit

朱莉娅0.6，64字节

g(x,i)=0∉x%(2:x-1)?1:1+g(x+i,i);x->g(x,1)&(g(x-1,-1)<g(x+1,1))

Python 2，81个字节

n=input()
a=b=c=i=2;p=1
while b<n:
 p*=i;i+=1
 if p*p%i:a,b,c=b,c,i
print a+c>2*b

在线尝试！

将威尔逊定理用于素性检验。