Der Primcluster einer ganzen Zahl N höher als 2 ist definiert als das Paar, das aus der höchsten Primzahl gebildet wird, die streng niedriger als N ist, und der niedrigsten Primzahl, die streng höher als N ist .

Beachten Sie, dass nach der obigen Definition, wenn die Ganzzahl selbst eine Primzahl selbst ist, ihr Primzahlcluster das Paar der vorhergehenden und nachfolgenden Primzahlen ist.

Aufgabe

Wenn zwei ganze Zahlen, N , M ( N, M ≥ 3 ) gegeben sind, wird ein Wahrheits- / Falschwert ausgegeben, der darauf basiert, ob N und M den gleichen Primcluster haben.

Dies ist Code-Golf , daher ist das Ziel, Ihre Byteanzahl so weit wie möglich zu reduzieren. Somit gewinnt der kürzeste Code in jeder Programmiersprache .

Testfälle / Beispiele

Zum Beispiel die Haupt Cluster von 9 sind [7, 11], weil:

• 7 ist die höchste Primzahl, die streng niedriger als 9 ist , und
• 11 ist die niedrigste Primzahl, die streng höher als 9 ist .

Auch die die Haupt Cluster von 67 ist [61, 71]( man beachte , dass 67 eine Primzahl ist).

Wahrheitspaare

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

Falsche Paare

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

Gelee , 6 4 3 5 4 Bytes

rÆPE

Probieren Sie es online aus! oder Probieren Sie alle Testfälle aus .

Wie es funktioniert

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

Funktioniert, weil zwei Zahlen unterschiedliche Primzahlen haben, wenn sich zwischen ihnen eine Primzahl befindet oder eine der beiden Zahlen selbst eine Primzahl ist. es sei denn , beide Zahlen gleich sind, in welchem Fall Ekehrt 1sowieso (alle Elemente in einem einzigen Array-Elemente gleich sind).

Perl 6 , 52 Bytes

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

Probier es aus

Erweitert:

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

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]

Probieren Sie es online aus!

Ruby , ₅₇ 54 Bytes

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

Probieren Sie es online aus!

Verwendet den schrecklichen Regex-Primalitätstest von meiner Antwort (die ich vergessen hatte, bis ich darauf geklickt habe) auf die verwandte Frage. Ist diese Zahl eine Primzahl? . Da wir N, M ≥ 3 haben, kann die Prüfung für 1 aus dem Muster entfernt werden, wodurch die Anzahl der Bytes geringer ist als bei Verwendung des eingebauten Musters.

Hinweis: Der Regex-Primalitätstest ist pathologisch und unglaublich ineffizient. Ich glaube, es ist mindestens O (n!), Obwohl ich momentan keine Zeit habe, es herauszufinden. Es dauerte zwölf Sekunden, bis 100.001 überprüft wurden, und es wurde fünf oder zehn Minuten lang auf 1.000.001 geschliffen, bevor ich es stornierte. Verwendung / Missbrauch auf eigenes Risiko.

Netzhaut , 58 Bytes

\b(.+)¶\1\b

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

Probieren Sie es online aus! Erläuterung:

\b(.+)¶\1\b

Wenn beide Eingänge gleich sind, löschen Sie einfach alles und fallen Sie am Ende auf Ausgang 1 durch.

.+
$*

In unary konvertieren.

O`

Nach Reihenfolge sortieren.

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

Erweitern Sie auf einen Bereich aller Zahlen.

A`^(11+)\1+$

Löschen Sie alle zusammengesetzten Zahlen.

^$

Wenn keine Zahlen mehr vorhanden sind, geben Sie 1 aus, andernfalls 0.

PARI / GP, 28 Bytes

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

Probieren Sie es online mit allen Testfällen aus!

Rückgabe 0oder 1(übliche PARI / GP "Boolean" -Werte).

Erläuterung:

vmuss ein Vektor (oder ein Spaltenvektor oder eine Liste) mit den beiden Zahlen Nund Mals Koordinaten sein. Zum Beispiel [8, 10]. Dann swird die "Menge" aus diesen Zahlen erstellt, die entweder ein Ein-Koordinaten-Vektor (wenn N==M) oder ein Zwei-Koordinaten-Vektor mit ansonsten sortierten Einträgen ist.

Wenn dann die Anzahl #sder Koordinaten snur eins ist, erhalten wir 1(wahr). Andernfalls primeswird ein Vektor aller Primzahlen im geschlossenen Intervall von s[1]bis zurückgegeben s[2]. Die Negation !davon ergibt, 1wenn der Vektor leer ist, während die Negation eines Vektors von einem oder mehreren Einträgen ungleich Null (hier eine oder mehrere Primzahlen) ergibt 0.

JavaScript (ES6), 57 56 Byte

Nimmt Eingaben in die Curry-Syntax vor (a)(b). Rückgabe 0oder 1.

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

Testfälle

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

Wie?

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 Bytes

-17 von Giuseppe

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

Probieren Sie es online aus!

Ziemlich einfache Anwendung der Jelly-Lösung von ETHProductions . Haupt interessant Mitnehmen ist ist , dass mit R Booleschen Vektoren any(x)==all(x)entspricht min(x)==max(x).

C (gcc) 153 146 Bytes

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 von Jonathan Frech

Definiert eine Funktion , hdie in zwei Takes ints und kehrt 1für truthy und 0für Falsey

Probieren Sie es online aus!

n ist eine Funktion, die 1 zurückgibt, wenn ihr Argument nicht prim ist.

g ist ein Makro, das sein erstes und zweites Argument auf die nächste Primzahl setzt, die kleiner als bzw. größer als das dritte Argument ist

hDies gilt gfür beide Eingänge und prüft, ob die Ausgänge gleich sind.

Gelee , 6 Bytes

ÆpżÆnE

Probieren Sie es online aus!

-2 danke an Dennis .

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

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

Probieren Sie es online aus!

Vielen Dank an Adám für 10 Bytes.

Die Linie ⎕CY'dfns'( C OP Y ) benötigt wird , um die zu importierende DFNS ( d ynamische f unctio ns ) Sammlung, mit Default Dyalog APL installiert enthalten.

Wie es funktioniert:

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

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

Probieren Sie es online aus!

C (gcc) , 103 Bytes 100 Bytes

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

Probieren Sie es online aus!

Haskell , 81 Bytes

Eine einfache Lösung:

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

Probieren Sie es online aus!

Mathematica, 39 27 26 Bytes

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

Erweitert:

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

Verwendungszweck:

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

Beiträge: -12 Bytes von Jenny_mathy , -1 Bytes von Martin Ender

J , 15 Bytes

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

Wie es funktioniert:

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

Probieren Sie es online aus!