的素簇的整数的Ñ高于2被定义为通过最高素所形成的一对严格低于Ñ和最低素严格高于Ñ。

请注意，按照上述定义，如果整数是质数本身，然后其首要簇是一对素数的前述和随后它。

任务

给定两个整数，整数N，M（N，M≥3），根据N和M是否具有相同的素数簇，输出真实/虚假值。

这是代码高尔夫球，因此目的是尽可能减少字节数。因此，以每种编程语言中最短的代码为准。

测试用例/示例

例如，9的素类为[7, 11]，因为：

• 7是严格低于9的最高素数，并且
• 11是严格高于9的最低素数。

同样，素数群集67是[61, 71]（请注意67是素数）。

真对

8、10
20、22
65、65
73、73
86、84
326、318
513、518

假对

4、5
6、8
409、401
348、347
419、418
311、313
326、305

果冻，6 4 3 5 4字节

rÆPE

在线尝试！或尝试所有测试用例。

怎么运行的

rÆPE    Main link. Arguments: N, M
r       Yield the range of integers between N and M, inclusive.
 ÆP     For each integer, yield 1 if it is prime, 0 otherwise.
   E    Yield 1 if all items are equal (none in the range were prime,
        or there's only one item).

之所以有用，是因为两个数字具有不同的素数簇，前提是它们之间有一个素数，或者两个数本身都是素数。除非两个数字相同，否则无论如何都会E返回1（单项数组中的所有项都相等）。

Perl 6，52个字节

{[eqv] @_».&{(($_...0),$_..*)».first(*.is-prime)}}

测试一下

展开：

{  # bare block lambda with implicit slurpy input ｢@_｣

  [eqv]               # see if each sub list is equivalent

    @_».&{            # for each value in the input

      (

        ( $_ ... 0 ), # decreasing Seq
          $_ ..  *    # Range

      )».first(*.is-prime) # find the first prime from both the Seq and Range

    }
}

Python 3中，103个 95 91字节

lambda*z:len({*z})<2or[1for i in range(min(z),max(z)+1)if all(i%k for k in range(2,i))]<[0]

在线尝试！

红宝石，₅₇ 54字节

->n,m{[*n..m,*m..n].all?{|x|?1*x=~/^(11+)\1+$/}||n==m}

在线尝试！

从我的答案（直到我单击它之前就忘记了）到相关问题使用可怕的正则表达式素数测试，这个数字是素数吗？。由于我们有N，M≥3，因此可以从模式中删除对1的检查，从而使字节数少于使用内置计数的字节数。

注意：正则表达式素数测试在病理学上效率低下。我相信至少是O（n！），尽管我现在没有时间弄清楚它。我花了十二秒钟检查了100,001，然后在取消1,000,001上磨了五到十分钟。使用/滥用后果自负。

视网膜 58字节

\b(.+)¶\1\b

.+
$*
O`
+`\b(1+)¶11\1
$1¶1$&
A`^(11+)\1+$
^$

在线尝试！说明：

\b(.+)¶\1\b

如果两个输入都相同，则只需删除所有内容，最后进入输出1。

.+
$*

转换为一元。

O`

排序。

+`\b(1+)¶11\1
$1¶1$&

扩展到所有数字的范围。

A`^(11+)\1+$

删除所有复合数字。

^$

如果没有数字，则输出1，否则输出0。

PARI / GP，28个字节

v->s=Set(v);#s<2||!primes(s)

在线尝试所有测试用例！

退货0或1（通常为PARI / GP“布尔”值）。

说明：

v必须是具有两个数字N并M作为坐标的向量（或列向量或列表）。例如[8, 10]。然后s将是由这些数字组成的“集合”，它可以是一个单坐标矢量（if N==M），或者是一个带有已排序条目的二坐标矢量。

然后，如果输入#s的坐标数s仅为1，则得出1（真实）。否则，primes将返回从s[1]到的闭合间隔中所有素数的向量s[2]。否定!的，这将使1如果向量是空的，而一个或多个非零项（这里的一个或多个素数）的矢量的否定会给0。

JavaScript（ES6），57 56字节

以currying语法接受输入(a)(b)。返回0或1。

a=>b=>a==b|!(g=k=>a%--k?g(k):k<2||a-b&&g(a+=a<b||-1))(a)

测试用例

let f =

a=>b=>a==b|!(g=k=>a%--k?g(k):k<2||a-b&&g(a+=a<b||-1))(a)

console.log('Truthy')
console.log(f(8)(10))
console.log(f(20)(22))
console.log(f(65)(65))
console.log(f(73)(73))
console.log(f(86)(84))
console.log(f(326)(318))
console.log(f(513)(518))

console.log('Falsy')
console.log(f(4)(5))
console.log(f(6)(8))
console.log(f(409)(401))
console.log(f(348)(347))
console.log(f(419)(418))
console.log(f(311)(313))

怎么样？

a => b =>                 // given a and b
  a == b |                // if a equals b, force success right away
  !(g = k =>              // g = recursive function taking k
    a % --k ?             //   decrement k; if k doesn't divide a:
      g(k)                //     recursive calls until it does
    :                     //   else:
      k < 2 ||            //     if k = 1: a is prime -> return true (failure)
      a - b &&            //     if a equals b: neither the original input integers nor
                          //     any integer between them are prime -> return 0 (success)
      g(a += a < b || -1) //     else: recursive call with a moving towards b
  )(a)                    // initial call to g()

R，63 46字节

朱塞佩-17

function(a,b)!sd(range(numbers::isPrime(a:b)))

在线尝试！

ETHProductions的Jelly解决方案非常简单的应用。主要的有趣之处是R布尔向量any(x)==all(x)等于min(x)==max(x)。

C（gcc）， 153146字节

i,B;n(j){for(B=i=2;i<j;)B*=j%i++>0;return!B;}
#define g(l,m,o)for(l=o;n(--l););for(m=o;n(++m););
a;b;c;d;h(e,f){g(a,b,e)g(c,d,f)return!(a-c|b-d);}

乔纳森·弗雷奇（Jonathan Frech）的-7

定义一个h接受两个的函数int s并返回1true和0false

在线尝试！

n 是一个函数，如果其参数不是素数则返回1。

g 是一个宏，将第一个和第二个参数设置为小于和大于（分别）第三个参数的下一个质数

h 确实 g对于两个输入并检查是否输出是相同的。

果冻，6个字节

ÆpżÆnE

在线尝试！

-2感谢Dennis。

APL（Dyalog Unicode），18 + 16 = 34 24字节

⎕CY'dfns'
∧/=/4 ¯4∘.pco⎕

在线尝试！

感谢Adám提供10个字节。

线⎕CY'dfns'（C ^ OP Ý）需要导入DFN和（d ynamic ˚F unctio 纳秒）收集，包含默认Dyalog APL安装。

怎么运行的：

∧/=/4 ¯4∘.pco⎕ ⍝ Main function. This is a tradfn body.
             ⎕ ⍝ The 'quad' takes the input (in this case, 2 integers separated by a comma.
          pco  ⍝ The 'p-colon' function, based on p: in J. Used to work with primes.
    4 ¯4∘.     ⍝ Applies 4pco (first prime greater than) and ¯4pco (first prime smaller than) to each argument.
  =/           ⍝ Compares the two items on each row
∧/             ⍝ Applies the logical AND between the results.
               ⍝ This yields 1 iff the prime clusters are equal.

Python 2中，87 86个字节

lambda*v:v[0]==v[1]or{1}-{all(v%i for i in range(2,v))for v in range(min(v),max(v)+1)}

在线尝试！

C（gcc），103字节 100字节

i,j,p,s;f(m,n){s=1;for(i=m>n?i=n,n=m,m=i:m;i<=n;i++,p?s=m==n:0)for(p=j=2;j<i;)p=i%j++?p:0;return s;}

在线尝试！

哈斯克尔，81个字节

一个简单的解决方案：

p z=[x|x<-z,all((0/=).mod x)[2..x-1]]!!0
c x=(p[x-1,x-2..],p[x+1..])
x!y=c x==c y

在线尝试！

Mathematica，39 27 26字节

Equal@@#~NextPrime~{-1,1}&

展开：

                         &  # pure function, takes 2-member list as input
       #~NextPrime~{-1,1}   # infix version of NextPrime[#,{-1,1}], which
                            # finds the upper and lower bounds of each
                              argument's prime clusters
Equal@@                     # are those bounds pairs equal?

用法：

Equal@@#~NextPrime~{-1,1}& [{8, 10}]
(*  True  *)

Equal@@#~NextPrime~{-1,1}& [{6, 8}]
(*  False  *)

Equal@@#~NextPrime~{-1,1}& /@ {{8, 10}, {20, 22}, {65, 65}, 
    {73, 73}, {86, 84}, {326, 318}, {513, 518}}
(*  {True, True, True, True, True, True, True}  *)

Equal@@#~NextPrime~{-1,1}& /@ {{4, 5}, {6, 8}, {409, 401}, 
    {348, 347}, {419, 418}, {311, 313}}
(*  {False, False, False, False, False, False}  *)

贡献：Jenny_mathy -12个字节，Martin Ender -1个字节

J，15个字节

-:&(_4&p:,4&p:)

怎么运行的：

   &(           ) - applies the verb in the brackets to both arguments
            4&p:  - The smallest prime larger than y
      _4&p:       - The largest prime smaller than y
           ,      - append
 -:               - matches the pairs of the primes

在线尝试！