La grappe de choix d'un nombre entier N supérieur à 2 est défini comme étant le couple formé par le plus grand nombre premier strictement plus faible que N et le plus bas premier strictement supérieur à N .

Notez que suivant la définition ci-dessus, si l'entier est lui-même un nombre premier, alors son groupe principal est la paire des nombres premiers qui le précèdent et lui succèdent .

Tâche

Étant donné deux entiers entiers N , M ( N, M ≥ 3 ), émettent une valeur de vérité / fausse selon que N et M ont le même cluster principal.

Il s'agit de code-golf , l'objectif est donc de réduire autant que possible le nombre d'octets. Ainsi, le code le plus court dans chaque langage de programmation gagne.

Cas de test / Exemples

Par exemple, le premier groupe de 9 est [7, 11], car:

• 7 est le plus haut premier strictement inférieur à 9 , et
• 11 est le plus petit nombre premier strictement supérieur à 9 .

De même, le premier groupe de 67 est [61, 71](notez que 67 est un nombre premier).

Paires authentiques

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

Paires de fausses

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

Gelée , 6 4 3 5 4 octets

rÆPE

Essayez-le en ligne! ou Essayez tous les cas de test .

Comment ça fonctionne

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

Fonctionne parce que deux nombres ont des clusters premiers différents s'il y a un premier entre eux, ou l'un ou l'autre nombre est lui-même premier; sauf si les deux nombres sont identiques, auquel cas Eretourne 1quand même (tous les éléments d'un tableau à un seul élément sont égaux).

Perl 6 , 52 octets

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

Essaye-le

Étendu:

{  # 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 octets

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]

Essayez-le en ligne!

Rubis , ₅₇ 54 octets

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

Essayez-le en ligne!

Utilise l'horrible test de primalité des expressions rationnelles de ma réponse (que j'avais oublié jusqu'à ce que je clique dessus) à la question connexe. Ce nombre est-il un nombre premier? . Puisque nous avons N, M ≥ 3, la vérification de 1 peut être supprimée du modèle, ce qui fait que le nombre d'octets est inférieur à l'utilisation de la fonction intégrée.

Remarque: Le test de primalité des expressions rationnelles est pathologiquement, hilarante inefficace. Je crois que c'est au moins O (n!), Même si je n'ai pas le temps de le comprendre pour le moment. Il lui a fallu douze secondes pour vérifier 100 001 et broyait pendant cinq ou dix minutes sur 1 000 001 avant de l'annuler. Utilisez / abusez à vos propres risques.

Rétine , 58 octets

\b(.+)¶\1\b

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

Essayez-le en ligne! Explication:

\b(.+)¶\1\b

Si les deux entrées sont identiques, supprimez simplement tout et passez à la sortie 1 à la fin.

.+
$*

Convertissez en unaire.

O`

Trier dans l'ordre.

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

Développez à une plage de tous les nombres.

A`^(11+)\1+$

Supprimez tous les numéros composites.

^$

S'il ne reste plus de chiffres, affichez 1, sinon 0.

PARI / GP, 28 octets

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

Essayez-le en ligne avec tous les cas de test!

Retourne 0ou 1(valeurs PARI / GP "booléennes" habituelles).

Explication:

vdoit être un vecteur (ou un vecteur de colonne ou une liste) avec les deux nombres Net Mcomme coordonnées. Par exemple [8, 10]. Alors ssera "l'ensemble" fait à partir de ces nombres, qui est soit un vecteur à une coordonnée (si N==M), soit un vecteur à deux coordonnées avec des entrées triées sinon.

Ensuite, si le nombre #sde coordonnées dans sest juste un, nous obtenons 1(véridique). Sinon, primesrenverra un vecteur de tous les nombres premiers dans l'intervalle fermé de s[1]à s[2]. La négation !de cela donnera 1si le vecteur est vide, tandis que la négation d'un vecteur d'une ou plusieurs entrées non nulles (ici un ou plusieurs nombres premiers) donnera 0.

JavaScript (ES6), 57 56 octets

Prend des entrées dans la syntaxe de curry (a)(b). Renvoie 0ou 1.

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

Cas de test

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

Comment?

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 octets

-17 par Giuseppe

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

Essayez-le en ligne!

Application assez simple de la solution Jelly d' ETHProductions . Le principal point à retenir est que, avec R, les vecteurs booléens any(x)==all(x)sont équivalents à min(x)==max(x).

C (gcc), 153 146 octets

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);}

-7 de Jonathan Frech

Définit une fonction hqui prend deux ints et renvoie 1pour true et 0pour falsey

Essayez-le en ligne!

n est une fonction qui renvoie 1 si son argument n'est pas premier.

g est une macro qui définit ses premier et deuxième arguments au premier premier inférieur et supérieur à (respectivement) c'est le troisième argument

hfait gpour les deux entrées et vérifie si les sorties sont les mêmes.

Gelée , 6 octets

ÆpżÆnE

Essayez-le en ligne!

-2 merci à Dennis .

APL (Dyalog Unicode) , 18 + 16 = 34 24 octets

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

Essayez-le en ligne!

Merci à Adám pour 10 octets.

La ligne ⎕CY'dfns'( C OP Y ) est nécessaire pour importer les dfns ( f onctio ns d ynamiques ), incluse dans les installations Dyalog APL par défaut.

Comment ça fonctionne:

∧/=/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 octets

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

Essayez-le en ligne!

C (gcc) , 103 octets 100 octets

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;}

Essayez-le en ligne!

Haskell , 81 octets

Une solution simple:

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

Essayez-le en ligne!

Mathematica, 39 27 26 octets

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

Étendu:

                         &  # 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?

Usage:

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}  *)

Contributions: -12 octets par Jenny_mathy , -1 octet par Martin Ender

J , 15 octets

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

Comment ça fonctionne:

   &(           ) - 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

Essayez-le en ligne!